From 944bee877d5368beb2f38ce7dc213ecc264fde34 Mon Sep 17 00:00:00 2001 From: Cocos Robot <48829427+cocos-robot@users.noreply.github.com> Date: Tue, 22 Feb 2022 14:19:37 +0800 Subject: [PATCH] [ci skip][AUTO]: Automated genbindings update: e036af7757cc472184763ed0bae03fefeb88b401 (#10131) (#10143) Co-authored-by: cocos-robot --- native/cocos/bindings/auto/jsb_gfx_auto.cpp | 1327 +++++++++++++++++++ native/cocos/bindings/auto/jsb_gfx_auto.h | 58 + 2 files changed, 1385 insertions(+) diff --git a/native/cocos/bindings/auto/jsb_gfx_auto.cpp b/native/cocos/bindings/auto/jsb_gfx_auto.cpp index f6af54d11e..6dbe06a8d3 100644 --- a/native/cocos/bindings/auto/jsb_gfx_auto.cpp +++ b/native/cocos/bindings/auto/jsb_gfx_auto.cpp @@ -15,6 +15,28 @@ se::Object* __jsb_cc_gfx_Size_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_Size_class = nullptr; // NOLINT +static bool js_gfx_Size_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_Size_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_Size_copy : Error processing arguments"); + cc::gfx::Size& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_Size_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_Size_copy) + static bool js_gfx_Size_get_x(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -189,6 +211,7 @@ bool js_register_gfx_Size(se::Object* obj) // NOLINT(readability-identifier-nami cls->defineProperty("x", _SE(js_gfx_Size_get_x), _SE(js_gfx_Size_set_x)); cls->defineProperty("y", _SE(js_gfx_Size_get_y), _SE(js_gfx_Size_set_y)); cls->defineProperty("z", _SE(js_gfx_Size_get_z), _SE(js_gfx_Size_set_z)); + cls->defineFunction("copy", _SE(js_gfx_Size_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_Size_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -203,6 +226,28 @@ bool js_register_gfx_Size(se::Object* obj) // NOLINT(readability-identifier-nami se::Object* __jsb_cc_gfx_DeviceCaps_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_DeviceCaps_class = nullptr; // NOLINT +static bool js_gfx_DeviceCaps_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_DeviceCaps_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_DeviceCaps_copy : Error processing arguments"); + cc::gfx::DeviceCaps& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_DeviceCaps_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_DeviceCaps_copy) + static bool js_gfx_DeviceCaps_get_maxVertexAttributes(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -1042,6 +1087,7 @@ bool js_register_gfx_DeviceCaps(se::Object* obj) // NOLINT(readability-identifie cls->defineProperty("clipSpaceMinZ", _SE(js_gfx_DeviceCaps_get_clipSpaceMinZ), _SE(js_gfx_DeviceCaps_set_clipSpaceMinZ)); cls->defineProperty("screenSpaceSignY", _SE(js_gfx_DeviceCaps_get_screenSpaceSignY), _SE(js_gfx_DeviceCaps_set_screenSpaceSignY)); cls->defineProperty("clipSpaceSignY", _SE(js_gfx_DeviceCaps_get_clipSpaceSignY), _SE(js_gfx_DeviceCaps_set_clipSpaceSignY)); + cls->defineFunction("copy", _SE(js_gfx_DeviceCaps_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_DeviceCaps_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -1056,6 +1102,28 @@ bool js_register_gfx_DeviceCaps(se::Object* obj) // NOLINT(readability-identifie se::Object* __jsb_cc_gfx_Offset_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_Offset_class = nullptr; // NOLINT +static bool js_gfx_Offset_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_Offset_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_Offset_copy : Error processing arguments"); + cc::gfx::Offset& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_Offset_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_Offset_copy) + static bool js_gfx_Offset_get_x(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -1230,6 +1298,7 @@ bool js_register_gfx_Offset(se::Object* obj) // NOLINT(readability-identifier-na cls->defineProperty("x", _SE(js_gfx_Offset_get_x), _SE(js_gfx_Offset_set_x)); cls->defineProperty("y", _SE(js_gfx_Offset_get_y), _SE(js_gfx_Offset_set_y)); cls->defineProperty("z", _SE(js_gfx_Offset_get_z), _SE(js_gfx_Offset_set_z)); + cls->defineFunction("copy", _SE(js_gfx_Offset_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_Offset_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -1244,6 +1313,28 @@ bool js_register_gfx_Offset(se::Object* obj) // NOLINT(readability-identifier-na se::Object* __jsb_cc_gfx_Rect_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_Rect_class = nullptr; // NOLINT +static bool js_gfx_Rect_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_Rect_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_Rect_copy : Error processing arguments"); + cc::gfx::Rect& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_Rect_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_Rect_copy) + static bool js_gfx_Rect_get_x(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -1453,6 +1544,7 @@ bool js_register_gfx_Rect(se::Object* obj) // NOLINT(readability-identifier-nami cls->defineProperty("y", _SE(js_gfx_Rect_get_y), _SE(js_gfx_Rect_set_y)); cls->defineProperty("width", _SE(js_gfx_Rect_get_width), _SE(js_gfx_Rect_set_width)); cls->defineProperty("height", _SE(js_gfx_Rect_get_height), _SE(js_gfx_Rect_set_height)); + cls->defineFunction("copy", _SE(js_gfx_Rect_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_Rect_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -1467,6 +1559,28 @@ bool js_register_gfx_Rect(se::Object* obj) // NOLINT(readability-identifier-nami se::Object* __jsb_cc_gfx_Extent_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_Extent_class = nullptr; // NOLINT +static bool js_gfx_Extent_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_Extent_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_Extent_copy : Error processing arguments"); + cc::gfx::Extent& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_Extent_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_Extent_copy) + static bool js_gfx_Extent_get_width(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -1641,6 +1755,7 @@ bool js_register_gfx_Extent(se::Object* obj) // NOLINT(readability-identifier-na cls->defineProperty("width", _SE(js_gfx_Extent_get_width), _SE(js_gfx_Extent_set_width)); cls->defineProperty("height", _SE(js_gfx_Extent_get_height), _SE(js_gfx_Extent_set_height)); cls->defineProperty("depth", _SE(js_gfx_Extent_get_depth), _SE(js_gfx_Extent_set_depth)); + cls->defineFunction("copy", _SE(js_gfx_Extent_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_Extent_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -1655,6 +1770,28 @@ bool js_register_gfx_Extent(se::Object* obj) // NOLINT(readability-identifier-na se::Object* __jsb_cc_gfx_TextureSubresLayers_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_TextureSubresLayers_class = nullptr; // NOLINT +static bool js_gfx_TextureSubresLayers_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_TextureSubresLayers_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_TextureSubresLayers_copy : Error processing arguments"); + cc::gfx::TextureSubresLayers& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_TextureSubresLayers_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_TextureSubresLayers_copy) + static bool js_gfx_TextureSubresLayers_get_mipLevel(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -1829,6 +1966,7 @@ bool js_register_gfx_TextureSubresLayers(se::Object* obj) // NOLINT(readability- cls->defineProperty("mipLevel", _SE(js_gfx_TextureSubresLayers_get_mipLevel), _SE(js_gfx_TextureSubresLayers_set_mipLevel)); cls->defineProperty("baseArrayLayer", _SE(js_gfx_TextureSubresLayers_get_baseArrayLayer), _SE(js_gfx_TextureSubresLayers_set_baseArrayLayer)); cls->defineProperty("layerCount", _SE(js_gfx_TextureSubresLayers_get_layerCount), _SE(js_gfx_TextureSubresLayers_set_layerCount)); + cls->defineFunction("copy", _SE(js_gfx_TextureSubresLayers_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_TextureSubresLayers_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -1843,6 +1981,28 @@ bool js_register_gfx_TextureSubresLayers(se::Object* obj) // NOLINT(readability- se::Object* __jsb_cc_gfx_TextureSubresRange_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_TextureSubresRange_class = nullptr; // NOLINT +static bool js_gfx_TextureSubresRange_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_TextureSubresRange_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_TextureSubresRange_copy : Error processing arguments"); + cc::gfx::TextureSubresRange& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_TextureSubresRange_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_TextureSubresRange_copy) + static bool js_gfx_TextureSubresRange_get_baseMipLevel(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -2052,6 +2212,7 @@ bool js_register_gfx_TextureSubresRange(se::Object* obj) // NOLINT(readability-i cls->defineProperty("levelCount", _SE(js_gfx_TextureSubresRange_get_levelCount), _SE(js_gfx_TextureSubresRange_set_levelCount)); cls->defineProperty("baseArrayLayer", _SE(js_gfx_TextureSubresRange_get_baseArrayLayer), _SE(js_gfx_TextureSubresRange_set_baseArrayLayer)); cls->defineProperty("layerCount", _SE(js_gfx_TextureSubresRange_get_layerCount), _SE(js_gfx_TextureSubresRange_set_layerCount)); + cls->defineFunction("copy", _SE(js_gfx_TextureSubresRange_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_TextureSubresRange_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -2066,6 +2227,28 @@ bool js_register_gfx_TextureSubresRange(se::Object* obj) // NOLINT(readability-i se::Object* __jsb_cc_gfx_TextureCopy_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_TextureCopy_class = nullptr; // NOLINT +static bool js_gfx_TextureCopy_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_TextureCopy_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_TextureCopy_copy : Error processing arguments"); + cc::gfx::TextureCopy& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_TextureCopy_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_TextureCopy_copy) + static bool js_gfx_TextureCopy_get_srcSubres(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -2310,6 +2493,7 @@ bool js_register_gfx_TextureCopy(se::Object* obj) // NOLINT(readability-identifi cls->defineProperty("dstSubres", _SE(js_gfx_TextureCopy_get_dstSubres), _SE(js_gfx_TextureCopy_set_dstSubres)); cls->defineProperty("dstOffset", _SE(js_gfx_TextureCopy_get_dstOffset), _SE(js_gfx_TextureCopy_set_dstOffset)); cls->defineProperty("extent", _SE(js_gfx_TextureCopy_get_extent), _SE(js_gfx_TextureCopy_set_extent)); + cls->defineFunction("copy", _SE(js_gfx_TextureCopy_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_TextureCopy_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -2324,6 +2508,28 @@ bool js_register_gfx_TextureCopy(se::Object* obj) // NOLINT(readability-identifi se::Object* __jsb_cc_gfx_TextureBlit_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_TextureBlit_class = nullptr; // NOLINT +static bool js_gfx_TextureBlit_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_TextureBlit_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_TextureBlit_copy : Error processing arguments"); + cc::gfx::TextureBlit& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_TextureBlit_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_TextureBlit_copy) + static bool js_gfx_TextureBlit_get_srcSubres(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -2603,6 +2809,7 @@ bool js_register_gfx_TextureBlit(se::Object* obj) // NOLINT(readability-identifi cls->defineProperty("dstSubres", _SE(js_gfx_TextureBlit_get_dstSubres), _SE(js_gfx_TextureBlit_set_dstSubres)); cls->defineProperty("dstOffset", _SE(js_gfx_TextureBlit_get_dstOffset), _SE(js_gfx_TextureBlit_set_dstOffset)); cls->defineProperty("dstExtent", _SE(js_gfx_TextureBlit_get_dstExtent), _SE(js_gfx_TextureBlit_set_dstExtent)); + cls->defineFunction("copy", _SE(js_gfx_TextureBlit_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_TextureBlit_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -2617,6 +2824,28 @@ bool js_register_gfx_TextureBlit(se::Object* obj) // NOLINT(readability-identifi se::Object* __jsb_cc_gfx_BufferTextureCopy_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_BufferTextureCopy_class = nullptr; // NOLINT +static bool js_gfx_BufferTextureCopy_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_BufferTextureCopy_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_BufferTextureCopy_copy : Error processing arguments"); + cc::gfx::BufferTextureCopy& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_BufferTextureCopy_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_BufferTextureCopy_copy) + static bool js_gfx_BufferTextureCopy_get_buffStride(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -2861,6 +3090,7 @@ bool js_register_gfx_BufferTextureCopy(se::Object* obj) // NOLINT(readability-id cls->defineProperty("texOffset", _SE(js_gfx_BufferTextureCopy_get_texOffset), _SE(js_gfx_BufferTextureCopy_set_texOffset)); cls->defineProperty("texExtent", _SE(js_gfx_BufferTextureCopy_get_texExtent), _SE(js_gfx_BufferTextureCopy_set_texExtent)); cls->defineProperty("texSubres", _SE(js_gfx_BufferTextureCopy_get_texSubres), _SE(js_gfx_BufferTextureCopy_set_texSubres)); + cls->defineFunction("copy", _SE(js_gfx_BufferTextureCopy_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_BufferTextureCopy_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -2875,6 +3105,28 @@ bool js_register_gfx_BufferTextureCopy(se::Object* obj) // NOLINT(readability-id se::Object* __jsb_cc_gfx_Viewport_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_Viewport_class = nullptr; // NOLINT +static bool js_gfx_Viewport_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_Viewport_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_Viewport_copy : Error processing arguments"); + cc::gfx::Viewport& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_Viewport_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_Viewport_copy) + static bool js_gfx_Viewport_get_left(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -3154,6 +3406,7 @@ bool js_register_gfx_Viewport(se::Object* obj) // NOLINT(readability-identifier- cls->defineProperty("height", _SE(js_gfx_Viewport_get_height), _SE(js_gfx_Viewport_set_height)); cls->defineProperty("minDepth", _SE(js_gfx_Viewport_get_minDepth), _SE(js_gfx_Viewport_set_minDepth)); cls->defineProperty("maxDepth", _SE(js_gfx_Viewport_get_maxDepth), _SE(js_gfx_Viewport_set_maxDepth)); + cls->defineFunction("copy", _SE(js_gfx_Viewport_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_Viewport_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -3168,6 +3421,28 @@ bool js_register_gfx_Viewport(se::Object* obj) // NOLINT(readability-identifier- se::Object* __jsb_cc_gfx_Color_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_Color_class = nullptr; // NOLINT +static bool js_gfx_Color_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_Color_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_Color_copy : Error processing arguments"); + cc::gfx::Color& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_Color_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_Color_copy) + static bool js_gfx_Color_get_x(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -3377,6 +3652,7 @@ bool js_register_gfx_Color(se::Object* obj) // NOLINT(readability-identifier-nam cls->defineProperty("y", _SE(js_gfx_Color_get_y), _SE(js_gfx_Color_set_y)); cls->defineProperty("z", _SE(js_gfx_Color_get_z), _SE(js_gfx_Color_set_z)); cls->defineProperty("w", _SE(js_gfx_Color_get_w), _SE(js_gfx_Color_set_w)); + cls->defineFunction("copy", _SE(js_gfx_Color_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_Color_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -3391,6 +3667,28 @@ bool js_register_gfx_Color(se::Object* obj) // NOLINT(readability-identifier-nam se::Object* __jsb_cc_gfx_BindingMappingInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_BindingMappingInfo_class = nullptr; // NOLINT +static bool js_gfx_BindingMappingInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_BindingMappingInfo_copy : Error processing arguments"); + cc::gfx::BindingMappingInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_BindingMappingInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_BindingMappingInfo_copy) + static bool js_gfx_BindingMappingInfo_get_maxBlockCounts(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -3740,6 +4038,7 @@ bool js_register_gfx_BindingMappingInfo(se::Object* obj) // NOLINT(readability-i cls->defineProperty("maxImageCounts", _SE(js_gfx_BindingMappingInfo_get_maxImageCounts), _SE(js_gfx_BindingMappingInfo_set_maxImageCounts)); cls->defineProperty("maxSubpassInputCounts", _SE(js_gfx_BindingMappingInfo_get_maxSubpassInputCounts), _SE(js_gfx_BindingMappingInfo_set_maxSubpassInputCounts)); cls->defineProperty("setIndices", _SE(js_gfx_BindingMappingInfo_get_setIndices), _SE(js_gfx_BindingMappingInfo_set_setIndices)); + cls->defineFunction("copy", _SE(js_gfx_BindingMappingInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_BindingMappingInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -3754,6 +4053,28 @@ bool js_register_gfx_BindingMappingInfo(se::Object* obj) // NOLINT(readability-i se::Object* __jsb_cc_gfx_SwapchainInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_SwapchainInfo_class = nullptr; // NOLINT +static bool js_gfx_SwapchainInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_SwapchainInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_SwapchainInfo_copy : Error processing arguments"); + cc::gfx::SwapchainInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_SwapchainInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_SwapchainInfo_copy) + static bool js_gfx_SwapchainInfo_get_windowHandle(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -3963,6 +4284,7 @@ bool js_register_gfx_SwapchainInfo(se::Object* obj) // NOLINT(readability-identi cls->defineProperty("vsyncMode", _SE(js_gfx_SwapchainInfo_get_vsyncMode), _SE(js_gfx_SwapchainInfo_set_vsyncMode)); cls->defineProperty("width", _SE(js_gfx_SwapchainInfo_get_width), _SE(js_gfx_SwapchainInfo_set_width)); cls->defineProperty("height", _SE(js_gfx_SwapchainInfo_get_height), _SE(js_gfx_SwapchainInfo_set_height)); + cls->defineFunction("copy", _SE(js_gfx_SwapchainInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_SwapchainInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -3977,6 +4299,28 @@ bool js_register_gfx_SwapchainInfo(se::Object* obj) // NOLINT(readability-identi se::Object* __jsb_cc_gfx_DeviceInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_DeviceInfo_class = nullptr; // NOLINT +static bool js_gfx_DeviceInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_DeviceInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_DeviceInfo_copy : Error processing arguments"); + cc::gfx::DeviceInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_DeviceInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_DeviceInfo_copy) + static bool js_gfx_DeviceInfo_get_bindingMappingInfo(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -4065,6 +4409,7 @@ bool js_register_gfx_DeviceInfo(se::Object* obj) // NOLINT(readability-identifie auto* cls = se::Class::create("DeviceInfo", obj, nullptr, _SE(js_gfx_DeviceInfo_constructor)); cls->defineProperty("bindingMappingInfo", _SE(js_gfx_DeviceInfo_get_bindingMappingInfo), _SE(js_gfx_DeviceInfo_set_bindingMappingInfo)); + cls->defineFunction("copy", _SE(js_gfx_DeviceInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_DeviceInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -4079,6 +4424,28 @@ bool js_register_gfx_DeviceInfo(se::Object* obj) // NOLINT(readability-identifie se::Object* __jsb_cc_gfx_BufferInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_BufferInfo_class = nullptr; // NOLINT +static bool js_gfx_BufferInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_BufferInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_BufferInfo_copy : Error processing arguments"); + cc::gfx::BufferInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_BufferInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_BufferInfo_copy) + static bool js_gfx_BufferInfo_get_usage(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -4323,6 +4690,7 @@ bool js_register_gfx_BufferInfo(se::Object* obj) // NOLINT(readability-identifie cls->defineProperty("size", _SE(js_gfx_BufferInfo_get_size), _SE(js_gfx_BufferInfo_set_size)); cls->defineProperty("stride", _SE(js_gfx_BufferInfo_get_stride), _SE(js_gfx_BufferInfo_set_stride)); cls->defineProperty("flags", _SE(js_gfx_BufferInfo_get_flags), _SE(js_gfx_BufferInfo_set_flags)); + cls->defineFunction("copy", _SE(js_gfx_BufferInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_BufferInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -4337,6 +4705,28 @@ bool js_register_gfx_BufferInfo(se::Object* obj) // NOLINT(readability-identifie se::Object* __jsb_cc_gfx_BufferViewInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_BufferViewInfo_class = nullptr; // NOLINT +static bool js_gfx_BufferViewInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_BufferViewInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_BufferViewInfo_copy : Error processing arguments"); + cc::gfx::BufferViewInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_BufferViewInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_BufferViewInfo_copy) + static bool js_gfx_BufferViewInfo_get_buffer(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -4511,6 +4901,7 @@ bool js_register_gfx_BufferViewInfo(se::Object* obj) // NOLINT(readability-ident cls->defineProperty("buffer", _SE(js_gfx_BufferViewInfo_get_buffer), _SE(js_gfx_BufferViewInfo_set_buffer)); cls->defineProperty("offset", _SE(js_gfx_BufferViewInfo_get_offset), _SE(js_gfx_BufferViewInfo_set_offset)); cls->defineProperty("range", _SE(js_gfx_BufferViewInfo_get_range), _SE(js_gfx_BufferViewInfo_set_range)); + cls->defineFunction("copy", _SE(js_gfx_BufferViewInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_BufferViewInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -4525,6 +4916,28 @@ bool js_register_gfx_BufferViewInfo(se::Object* obj) // NOLINT(readability-ident se::Object* __jsb_cc_gfx_DrawInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_DrawInfo_class = nullptr; // NOLINT +static bool js_gfx_DrawInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_DrawInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_DrawInfo_copy : Error processing arguments"); + cc::gfx::DrawInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_DrawInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_DrawInfo_copy) + static bool js_gfx_DrawInfo_get_vertexCount(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -4839,6 +5252,7 @@ bool js_register_gfx_DrawInfo(se::Object* obj) // NOLINT(readability-identifier- cls->defineProperty("vertexOffset", _SE(js_gfx_DrawInfo_get_vertexOffset), _SE(js_gfx_DrawInfo_set_vertexOffset)); cls->defineProperty("instanceCount", _SE(js_gfx_DrawInfo_get_instanceCount), _SE(js_gfx_DrawInfo_set_instanceCount)); cls->defineProperty("firstInstance", _SE(js_gfx_DrawInfo_get_firstInstance), _SE(js_gfx_DrawInfo_set_firstInstance)); + cls->defineFunction("copy", _SE(js_gfx_DrawInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_DrawInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -4853,6 +5267,28 @@ bool js_register_gfx_DrawInfo(se::Object* obj) // NOLINT(readability-identifier- se::Object* __jsb_cc_gfx_DispatchInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_DispatchInfo_class = nullptr; // NOLINT +static bool js_gfx_DispatchInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_DispatchInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_DispatchInfo_copy : Error processing arguments"); + cc::gfx::DispatchInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_DispatchInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_DispatchInfo_copy) + static bool js_gfx_DispatchInfo_get_groupCountX(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -5097,6 +5533,7 @@ bool js_register_gfx_DispatchInfo(se::Object* obj) // NOLINT(readability-identif cls->defineProperty("groupCountZ", _SE(js_gfx_DispatchInfo_get_groupCountZ), _SE(js_gfx_DispatchInfo_set_groupCountZ)); cls->defineProperty("indirectBuffer", _SE(js_gfx_DispatchInfo_get_indirectBuffer), _SE(js_gfx_DispatchInfo_set_indirectBuffer)); cls->defineProperty("indirectOffset", _SE(js_gfx_DispatchInfo_get_indirectOffset), _SE(js_gfx_DispatchInfo_set_indirectOffset)); + cls->defineFunction("copy", _SE(js_gfx_DispatchInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_DispatchInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -5111,6 +5548,28 @@ bool js_register_gfx_DispatchInfo(se::Object* obj) // NOLINT(readability-identif se::Object* __jsb_cc_gfx_IndirectBuffer_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_IndirectBuffer_class = nullptr; // NOLINT +static bool js_gfx_IndirectBuffer_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_IndirectBuffer_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_IndirectBuffer_copy : Error processing arguments"); + cc::gfx::IndirectBuffer& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_IndirectBuffer_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_IndirectBuffer_copy) + static bool js_gfx_IndirectBuffer_get_drawInfos(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -5199,6 +5658,7 @@ bool js_register_gfx_IndirectBuffer(se::Object* obj) // NOLINT(readability-ident auto* cls = se::Class::create("IndirectBuffer", obj, nullptr, _SE(js_gfx_IndirectBuffer_constructor)); cls->defineProperty("drawInfos", _SE(js_gfx_IndirectBuffer_get_drawInfos), _SE(js_gfx_IndirectBuffer_set_drawInfos)); + cls->defineFunction("copy", _SE(js_gfx_IndirectBuffer_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_IndirectBuffer_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -5213,6 +5673,28 @@ bool js_register_gfx_IndirectBuffer(se::Object* obj) // NOLINT(readability-ident se::Object* __jsb_cc_gfx_TextureInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_TextureInfo_class = nullptr; // NOLINT +static bool js_gfx_TextureInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_TextureInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_TextureInfo_copy : Error processing arguments"); + cc::gfx::TextureInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_TextureInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_TextureInfo_copy) + static bool js_gfx_TextureInfo_get_type(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -5667,6 +6149,7 @@ bool js_register_gfx_TextureInfo(se::Object* obj) // NOLINT(readability-identifi cls->defineProperty("samples", _SE(js_gfx_TextureInfo_get_samples), _SE(js_gfx_TextureInfo_set_samples)); cls->defineProperty("depth", _SE(js_gfx_TextureInfo_get_depth), _SE(js_gfx_TextureInfo_set_depth)); cls->defineProperty("externalRes", _SE(js_gfx_TextureInfo_get_externalRes), _SE(js_gfx_TextureInfo_set_externalRes)); + cls->defineFunction("copy", _SE(js_gfx_TextureInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_TextureInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -5681,6 +6164,28 @@ bool js_register_gfx_TextureInfo(se::Object* obj) // NOLINT(readability-identifi se::Object* __jsb_cc_gfx_TextureViewInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_TextureViewInfo_class = nullptr; // NOLINT +static bool js_gfx_TextureViewInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_TextureViewInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_TextureViewInfo_copy : Error processing arguments"); + cc::gfx::TextureViewInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_TextureViewInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_TextureViewInfo_copy) + static bool js_gfx_TextureViewInfo_get_texture(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -5995,6 +6500,7 @@ bool js_register_gfx_TextureViewInfo(se::Object* obj) // NOLINT(readability-iden cls->defineProperty("levelCount", _SE(js_gfx_TextureViewInfo_get_levelCount), _SE(js_gfx_TextureViewInfo_set_levelCount)); cls->defineProperty("baseLayer", _SE(js_gfx_TextureViewInfo_get_baseLayer), _SE(js_gfx_TextureViewInfo_set_baseLayer)); cls->defineProperty("layerCount", _SE(js_gfx_TextureViewInfo_get_layerCount), _SE(js_gfx_TextureViewInfo_set_layerCount)); + cls->defineFunction("copy", _SE(js_gfx_TextureViewInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_TextureViewInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -6009,6 +6515,28 @@ bool js_register_gfx_TextureViewInfo(se::Object* obj) // NOLINT(readability-iden se::Object* __jsb_cc_gfx_SamplerInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_SamplerInfo_class = nullptr; // NOLINT +static bool js_gfx_SamplerInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_SamplerInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_SamplerInfo_copy : Error processing arguments"); + cc::gfx::SamplerInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_SamplerInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_SamplerInfo_copy) + static bool js_gfx_SamplerInfo_get_minFilter(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -6358,6 +6886,7 @@ bool js_register_gfx_SamplerInfo(se::Object* obj) // NOLINT(readability-identifi cls->defineProperty("addressW", _SE(js_gfx_SamplerInfo_get_addressW), _SE(js_gfx_SamplerInfo_set_addressW)); cls->defineProperty("maxAnisotropy", _SE(js_gfx_SamplerInfo_get_maxAnisotropy), _SE(js_gfx_SamplerInfo_set_maxAnisotropy)); cls->defineProperty("cmpFunc", _SE(js_gfx_SamplerInfo_get_cmpFunc), _SE(js_gfx_SamplerInfo_set_cmpFunc)); + cls->defineFunction("copy", _SE(js_gfx_SamplerInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_SamplerInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -6372,6 +6901,28 @@ bool js_register_gfx_SamplerInfo(se::Object* obj) // NOLINT(readability-identifi se::Object* __jsb_cc_gfx_Uniform_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_Uniform_class = nullptr; // NOLINT +static bool js_gfx_Uniform_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_Uniform_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_Uniform_copy : Error processing arguments"); + cc::gfx::Uniform& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_Uniform_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_Uniform_copy) + static bool js_gfx_Uniform_get_name(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -6546,6 +7097,7 @@ bool js_register_gfx_Uniform(se::Object* obj) // NOLINT(readability-identifier-n cls->defineProperty("name", _SE(js_gfx_Uniform_get_name), _SE(js_gfx_Uniform_set_name)); cls->defineProperty("type", _SE(js_gfx_Uniform_get_type), _SE(js_gfx_Uniform_set_type)); cls->defineProperty("count", _SE(js_gfx_Uniform_get_count), _SE(js_gfx_Uniform_set_count)); + cls->defineFunction("copy", _SE(js_gfx_Uniform_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_Uniform_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -6560,6 +7112,28 @@ bool js_register_gfx_Uniform(se::Object* obj) // NOLINT(readability-identifier-n se::Object* __jsb_cc_gfx_UniformBlock_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_UniformBlock_class = nullptr; // NOLINT +static bool js_gfx_UniformBlock_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_UniformBlock_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_UniformBlock_copy : Error processing arguments"); + cc::gfx::UniformBlock& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_UniformBlock_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_UniformBlock_copy) + static bool js_gfx_UniformBlock_get_set(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -6804,6 +7378,7 @@ bool js_register_gfx_UniformBlock(se::Object* obj) // NOLINT(readability-identif cls->defineProperty("name", _SE(js_gfx_UniformBlock_get_name), _SE(js_gfx_UniformBlock_set_name)); cls->defineProperty("members", _SE(js_gfx_UniformBlock_get_members), _SE(js_gfx_UniformBlock_set_members)); cls->defineProperty("count", _SE(js_gfx_UniformBlock_get_count), _SE(js_gfx_UniformBlock_set_count)); + cls->defineFunction("copy", _SE(js_gfx_UniformBlock_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_UniformBlock_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -6818,6 +7393,28 @@ bool js_register_gfx_UniformBlock(se::Object* obj) // NOLINT(readability-identif se::Object* __jsb_cc_gfx_UniformSamplerTexture_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_UniformSamplerTexture_class = nullptr; // NOLINT +static bool js_gfx_UniformSamplerTexture_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_UniformSamplerTexture_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_UniformSamplerTexture_copy : Error processing arguments"); + cc::gfx::UniformSamplerTexture& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_UniformSamplerTexture_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_UniformSamplerTexture_copy) + static bool js_gfx_UniformSamplerTexture_get_set(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -7062,6 +7659,7 @@ bool js_register_gfx_UniformSamplerTexture(se::Object* obj) // NOLINT(readabilit cls->defineProperty("name", _SE(js_gfx_UniformSamplerTexture_get_name), _SE(js_gfx_UniformSamplerTexture_set_name)); cls->defineProperty("type", _SE(js_gfx_UniformSamplerTexture_get_type), _SE(js_gfx_UniformSamplerTexture_set_type)); cls->defineProperty("count", _SE(js_gfx_UniformSamplerTexture_get_count), _SE(js_gfx_UniformSamplerTexture_set_count)); + cls->defineFunction("copy", _SE(js_gfx_UniformSamplerTexture_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_UniformSamplerTexture_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -7076,6 +7674,28 @@ bool js_register_gfx_UniformSamplerTexture(se::Object* obj) // NOLINT(readabilit se::Object* __jsb_cc_gfx_UniformSampler_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_UniformSampler_class = nullptr; // NOLINT +static bool js_gfx_UniformSampler_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_UniformSampler_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_UniformSampler_copy : Error processing arguments"); + cc::gfx::UniformSampler& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_UniformSampler_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_UniformSampler_copy) + static bool js_gfx_UniformSampler_get_set(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -7285,6 +7905,7 @@ bool js_register_gfx_UniformSampler(se::Object* obj) // NOLINT(readability-ident cls->defineProperty("binding", _SE(js_gfx_UniformSampler_get_binding), _SE(js_gfx_UniformSampler_set_binding)); cls->defineProperty("name", _SE(js_gfx_UniformSampler_get_name), _SE(js_gfx_UniformSampler_set_name)); cls->defineProperty("count", _SE(js_gfx_UniformSampler_get_count), _SE(js_gfx_UniformSampler_set_count)); + cls->defineFunction("copy", _SE(js_gfx_UniformSampler_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_UniformSampler_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -7299,6 +7920,28 @@ bool js_register_gfx_UniformSampler(se::Object* obj) // NOLINT(readability-ident se::Object* __jsb_cc_gfx_UniformTexture_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_UniformTexture_class = nullptr; // NOLINT +static bool js_gfx_UniformTexture_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_UniformTexture_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_UniformTexture_copy : Error processing arguments"); + cc::gfx::UniformTexture& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_UniformTexture_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_UniformTexture_copy) + static bool js_gfx_UniformTexture_get_set(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -7543,6 +8186,7 @@ bool js_register_gfx_UniformTexture(se::Object* obj) // NOLINT(readability-ident cls->defineProperty("name", _SE(js_gfx_UniformTexture_get_name), _SE(js_gfx_UniformTexture_set_name)); cls->defineProperty("type", _SE(js_gfx_UniformTexture_get_type), _SE(js_gfx_UniformTexture_set_type)); cls->defineProperty("count", _SE(js_gfx_UniformTexture_get_count), _SE(js_gfx_UniformTexture_set_count)); + cls->defineFunction("copy", _SE(js_gfx_UniformTexture_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_UniformTexture_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -7557,6 +8201,28 @@ bool js_register_gfx_UniformTexture(se::Object* obj) // NOLINT(readability-ident se::Object* __jsb_cc_gfx_UniformStorageImage_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_UniformStorageImage_class = nullptr; // NOLINT +static bool js_gfx_UniformStorageImage_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_UniformStorageImage_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_UniformStorageImage_copy : Error processing arguments"); + cc::gfx::UniformStorageImage& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_UniformStorageImage_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_UniformStorageImage_copy) + static bool js_gfx_UniformStorageImage_get_set(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -7836,6 +8502,7 @@ bool js_register_gfx_UniformStorageImage(se::Object* obj) // NOLINT(readability- cls->defineProperty("type", _SE(js_gfx_UniformStorageImage_get_type), _SE(js_gfx_UniformStorageImage_set_type)); cls->defineProperty("count", _SE(js_gfx_UniformStorageImage_get_count), _SE(js_gfx_UniformStorageImage_set_count)); cls->defineProperty("memoryAccess", _SE(js_gfx_UniformStorageImage_get_memoryAccess), _SE(js_gfx_UniformStorageImage_set_memoryAccess)); + cls->defineFunction("copy", _SE(js_gfx_UniformStorageImage_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_UniformStorageImage_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -7850,6 +8517,28 @@ bool js_register_gfx_UniformStorageImage(se::Object* obj) // NOLINT(readability- se::Object* __jsb_cc_gfx_UniformStorageBuffer_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_UniformStorageBuffer_class = nullptr; // NOLINT +static bool js_gfx_UniformStorageBuffer_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_UniformStorageBuffer_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_UniformStorageBuffer_copy : Error processing arguments"); + cc::gfx::UniformStorageBuffer& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_UniformStorageBuffer_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_UniformStorageBuffer_copy) + static bool js_gfx_UniformStorageBuffer_get_set(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -8094,6 +8783,7 @@ bool js_register_gfx_UniformStorageBuffer(se::Object* obj) // NOLINT(readability cls->defineProperty("name", _SE(js_gfx_UniformStorageBuffer_get_name), _SE(js_gfx_UniformStorageBuffer_set_name)); cls->defineProperty("count", _SE(js_gfx_UniformStorageBuffer_get_count), _SE(js_gfx_UniformStorageBuffer_set_count)); cls->defineProperty("memoryAccess", _SE(js_gfx_UniformStorageBuffer_get_memoryAccess), _SE(js_gfx_UniformStorageBuffer_set_memoryAccess)); + cls->defineFunction("copy", _SE(js_gfx_UniformStorageBuffer_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_UniformStorageBuffer_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -8108,6 +8798,28 @@ bool js_register_gfx_UniformStorageBuffer(se::Object* obj) // NOLINT(readability se::Object* __jsb_cc_gfx_UniformInputAttachment_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_UniformInputAttachment_class = nullptr; // NOLINT +static bool js_gfx_UniformInputAttachment_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_UniformInputAttachment_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_UniformInputAttachment_copy : Error processing arguments"); + cc::gfx::UniformInputAttachment& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_UniformInputAttachment_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_UniformInputAttachment_copy) + static bool js_gfx_UniformInputAttachment_get_set(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -8317,6 +9029,7 @@ bool js_register_gfx_UniformInputAttachment(se::Object* obj) // NOLINT(readabili cls->defineProperty("binding", _SE(js_gfx_UniformInputAttachment_get_binding), _SE(js_gfx_UniformInputAttachment_set_binding)); cls->defineProperty("name", _SE(js_gfx_UniformInputAttachment_get_name), _SE(js_gfx_UniformInputAttachment_set_name)); cls->defineProperty("count", _SE(js_gfx_UniformInputAttachment_get_count), _SE(js_gfx_UniformInputAttachment_set_count)); + cls->defineFunction("copy", _SE(js_gfx_UniformInputAttachment_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_UniformInputAttachment_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -8331,6 +9044,28 @@ bool js_register_gfx_UniformInputAttachment(se::Object* obj) // NOLINT(readabili se::Object* __jsb_cc_gfx_ShaderStage_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_ShaderStage_class = nullptr; // NOLINT +static bool js_gfx_ShaderStage_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_ShaderStage_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_ShaderStage_copy : Error processing arguments"); + cc::gfx::ShaderStage& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_ShaderStage_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_ShaderStage_copy) + static bool js_gfx_ShaderStage_get_stage(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -8470,6 +9205,7 @@ bool js_register_gfx_ShaderStage(se::Object* obj) // NOLINT(readability-identifi cls->defineProperty("stage", _SE(js_gfx_ShaderStage_get_stage), _SE(js_gfx_ShaderStage_set_stage)); cls->defineProperty("source", _SE(js_gfx_ShaderStage_get_source), _SE(js_gfx_ShaderStage_set_source)); + cls->defineFunction("copy", _SE(js_gfx_ShaderStage_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_ShaderStage_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -8484,6 +9220,28 @@ bool js_register_gfx_ShaderStage(se::Object* obj) // NOLINT(readability-identifi se::Object* __jsb_cc_gfx_Attribute_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_Attribute_class = nullptr; // NOLINT +static bool js_gfx_Attribute_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_Attribute_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_Attribute_copy : Error processing arguments"); + cc::gfx::Attribute& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_Attribute_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_Attribute_copy) + static bool js_gfx_Attribute_get_name(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -8763,6 +9521,7 @@ bool js_register_gfx_Attribute(se::Object* obj) // NOLINT(readability-identifier cls->defineProperty("stream", _SE(js_gfx_Attribute_get_stream), _SE(js_gfx_Attribute_set_stream)); cls->defineProperty("isInstanced", _SE(js_gfx_Attribute_get_isInstanced), _SE(js_gfx_Attribute_set_isInstanced)); cls->defineProperty("location", _SE(js_gfx_Attribute_get_location), _SE(js_gfx_Attribute_set_location)); + cls->defineFunction("copy", _SE(js_gfx_Attribute_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_Attribute_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -8777,6 +9536,28 @@ bool js_register_gfx_Attribute(se::Object* obj) // NOLINT(readability-identifier se::Object* __jsb_cc_gfx_ShaderInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_ShaderInfo_class = nullptr; // NOLINT +static bool js_gfx_ShaderInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_ShaderInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_ShaderInfo_copy : Error processing arguments"); + cc::gfx::ShaderInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_ShaderInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_ShaderInfo_copy) + static bool js_gfx_ShaderInfo_get_name(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -9196,6 +9977,7 @@ bool js_register_gfx_ShaderInfo(se::Object* obj) // NOLINT(readability-identifie cls->defineProperty("textures", _SE(js_gfx_ShaderInfo_get_textures), _SE(js_gfx_ShaderInfo_set_textures)); cls->defineProperty("images", _SE(js_gfx_ShaderInfo_get_images), _SE(js_gfx_ShaderInfo_set_images)); cls->defineProperty("subpassInputs", _SE(js_gfx_ShaderInfo_get_subpassInputs), _SE(js_gfx_ShaderInfo_set_subpassInputs)); + cls->defineFunction("copy", _SE(js_gfx_ShaderInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_ShaderInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -9210,6 +9992,28 @@ bool js_register_gfx_ShaderInfo(se::Object* obj) // NOLINT(readability-identifie se::Object* __jsb_cc_gfx_InputAssemblerInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_InputAssemblerInfo_class = nullptr; // NOLINT +static bool js_gfx_InputAssemblerInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_InputAssemblerInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_InputAssemblerInfo_copy : Error processing arguments"); + cc::gfx::InputAssemblerInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_InputAssemblerInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_InputAssemblerInfo_copy) + static bool js_gfx_InputAssemblerInfo_get_attributes(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -9419,6 +10223,7 @@ bool js_register_gfx_InputAssemblerInfo(se::Object* obj) // NOLINT(readability-i cls->defineProperty("vertexBuffers", _SE(js_gfx_InputAssemblerInfo_get_vertexBuffers), _SE(js_gfx_InputAssemblerInfo_set_vertexBuffers)); cls->defineProperty("indexBuffer", _SE(js_gfx_InputAssemblerInfo_get_indexBuffer), _SE(js_gfx_InputAssemblerInfo_set_indexBuffer)); cls->defineProperty("indirectBuffer", _SE(js_gfx_InputAssemblerInfo_get_indirectBuffer), _SE(js_gfx_InputAssemblerInfo_set_indirectBuffer)); + cls->defineFunction("copy", _SE(js_gfx_InputAssemblerInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_InputAssemblerInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -9433,6 +10238,28 @@ bool js_register_gfx_InputAssemblerInfo(se::Object* obj) // NOLINT(readability-i se::Object* __jsb_cc_gfx_ColorAttachment_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_ColorAttachment_class = nullptr; // NOLINT +static bool js_gfx_ColorAttachment_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_ColorAttachment_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_ColorAttachment_copy : Error processing arguments"); + cc::gfx::ColorAttachment& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_ColorAttachment_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_ColorAttachment_copy) + static bool js_gfx_ColorAttachment_get_format(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -9712,6 +10539,7 @@ bool js_register_gfx_ColorAttachment(se::Object* obj) // NOLINT(readability-iden cls->defineProperty("storeOp", _SE(js_gfx_ColorAttachment_get_storeOp), _SE(js_gfx_ColorAttachment_set_storeOp)); cls->defineProperty("barrier", _SE(js_gfx_ColorAttachment_get_barrier), _SE(js_gfx_ColorAttachment_set_barrier)); cls->defineProperty("isGeneralLayout", _SE(js_gfx_ColorAttachment_get_isGeneralLayout), _SE(js_gfx_ColorAttachment_set_isGeneralLayout)); + cls->defineFunction("copy", _SE(js_gfx_ColorAttachment_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_ColorAttachment_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -9726,6 +10554,28 @@ bool js_register_gfx_ColorAttachment(se::Object* obj) // NOLINT(readability-iden se::Object* __jsb_cc_gfx_DepthStencilAttachment_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_DepthStencilAttachment_class = nullptr; // NOLINT +static bool js_gfx_DepthStencilAttachment_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_DepthStencilAttachment_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_DepthStencilAttachment_copy : Error processing arguments"); + cc::gfx::DepthStencilAttachment& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_DepthStencilAttachment_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_DepthStencilAttachment_copy) + static bool js_gfx_DepthStencilAttachment_get_format(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -10075,6 +10925,7 @@ bool js_register_gfx_DepthStencilAttachment(se::Object* obj) // NOLINT(readabili cls->defineProperty("stencilStoreOp", _SE(js_gfx_DepthStencilAttachment_get_stencilStoreOp), _SE(js_gfx_DepthStencilAttachment_set_stencilStoreOp)); cls->defineProperty("barrier", _SE(js_gfx_DepthStencilAttachment_get_barrier), _SE(js_gfx_DepthStencilAttachment_set_barrier)); cls->defineProperty("isGeneralLayout", _SE(js_gfx_DepthStencilAttachment_get_isGeneralLayout), _SE(js_gfx_DepthStencilAttachment_set_isGeneralLayout)); + cls->defineFunction("copy", _SE(js_gfx_DepthStencilAttachment_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_DepthStencilAttachment_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -10089,6 +10940,28 @@ bool js_register_gfx_DepthStencilAttachment(se::Object* obj) // NOLINT(readabili se::Object* __jsb_cc_gfx_SubpassInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_SubpassInfo_class = nullptr; // NOLINT +static bool js_gfx_SubpassInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_SubpassInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_SubpassInfo_copy : Error processing arguments"); + cc::gfx::SubpassInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_SubpassInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_SubpassInfo_copy) + static bool js_gfx_SubpassInfo_get_inputs(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -10438,6 +11311,7 @@ bool js_register_gfx_SubpassInfo(se::Object* obj) // NOLINT(readability-identifi cls->defineProperty("depthStencilResolve", _SE(js_gfx_SubpassInfo_get_depthStencilResolve), _SE(js_gfx_SubpassInfo_set_depthStencilResolve)); cls->defineProperty("depthResolveMode", _SE(js_gfx_SubpassInfo_get_depthResolveMode), _SE(js_gfx_SubpassInfo_set_depthResolveMode)); cls->defineProperty("stencilResolveMode", _SE(js_gfx_SubpassInfo_get_stencilResolveMode), _SE(js_gfx_SubpassInfo_set_stencilResolveMode)); + cls->defineFunction("copy", _SE(js_gfx_SubpassInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_SubpassInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -10452,6 +11326,28 @@ bool js_register_gfx_SubpassInfo(se::Object* obj) // NOLINT(readability-identifi se::Object* __jsb_cc_gfx_SubpassDependency_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_SubpassDependency_class = nullptr; // NOLINT +static bool js_gfx_SubpassDependency_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_SubpassDependency_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_SubpassDependency_copy : Error processing arguments"); + cc::gfx::SubpassDependency& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_SubpassDependency_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_SubpassDependency_copy) + static bool js_gfx_SubpassDependency_get_srcSubpass(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -10626,6 +11522,7 @@ bool js_register_gfx_SubpassDependency(se::Object* obj) // NOLINT(readability-id cls->defineProperty("srcSubpass", _SE(js_gfx_SubpassDependency_get_srcSubpass), _SE(js_gfx_SubpassDependency_set_srcSubpass)); cls->defineProperty("dstSubpass", _SE(js_gfx_SubpassDependency_get_dstSubpass), _SE(js_gfx_SubpassDependency_set_dstSubpass)); cls->defineProperty("barrier", _SE(js_gfx_SubpassDependency_get_barrier), _SE(js_gfx_SubpassDependency_set_barrier)); + cls->defineFunction("copy", _SE(js_gfx_SubpassDependency_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_SubpassDependency_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -10640,6 +11537,28 @@ bool js_register_gfx_SubpassDependency(se::Object* obj) // NOLINT(readability-id se::Object* __jsb_cc_gfx_RenderPassInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_RenderPassInfo_class = nullptr; // NOLINT +static bool js_gfx_RenderPassInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_RenderPassInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_RenderPassInfo_copy : Error processing arguments"); + cc::gfx::RenderPassInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_RenderPassInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_RenderPassInfo_copy) + static bool js_gfx_RenderPassInfo_get_colorAttachments(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -10849,6 +11768,7 @@ bool js_register_gfx_RenderPassInfo(se::Object* obj) // NOLINT(readability-ident cls->defineProperty("depthStencilAttachment", _SE(js_gfx_RenderPassInfo_get_depthStencilAttachment), _SE(js_gfx_RenderPassInfo_set_depthStencilAttachment)); cls->defineProperty("subpasses", _SE(js_gfx_RenderPassInfo_get_subpasses), _SE(js_gfx_RenderPassInfo_set_subpasses)); cls->defineProperty("dependencies", _SE(js_gfx_RenderPassInfo_get_dependencies), _SE(js_gfx_RenderPassInfo_set_dependencies)); + cls->defineFunction("copy", _SE(js_gfx_RenderPassInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_RenderPassInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -10863,6 +11783,28 @@ bool js_register_gfx_RenderPassInfo(se::Object* obj) // NOLINT(readability-ident se::Object* __jsb_cc_gfx_GeneralBarrierInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_GeneralBarrierInfo_class = nullptr; // NOLINT +static bool js_gfx_GeneralBarrierInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_GeneralBarrierInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_GeneralBarrierInfo_copy : Error processing arguments"); + cc::gfx::GeneralBarrierInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_GeneralBarrierInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_GeneralBarrierInfo_copy) + static bool js_gfx_GeneralBarrierInfo_get_prevAccesses(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -11002,6 +11944,7 @@ bool js_register_gfx_GeneralBarrierInfo(se::Object* obj) // NOLINT(readability-i cls->defineProperty("prevAccesses", _SE(js_gfx_GeneralBarrierInfo_get_prevAccesses), _SE(js_gfx_GeneralBarrierInfo_set_prevAccesses)); cls->defineProperty("nextAccesses", _SE(js_gfx_GeneralBarrierInfo_get_nextAccesses), _SE(js_gfx_GeneralBarrierInfo_set_nextAccesses)); + cls->defineFunction("copy", _SE(js_gfx_GeneralBarrierInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_GeneralBarrierInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -11016,6 +11959,28 @@ bool js_register_gfx_GeneralBarrierInfo(se::Object* obj) // NOLINT(readability-i se::Object* __jsb_cc_gfx_TextureBarrierInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_TextureBarrierInfo_class = nullptr; // NOLINT +static bool js_gfx_TextureBarrierInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_TextureBarrierInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_TextureBarrierInfo_copy : Error processing arguments"); + cc::gfx::TextureBarrierInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_TextureBarrierInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_TextureBarrierInfo_copy) + static bool js_gfx_TextureBarrierInfo_get_prevAccesses(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -11260,6 +12225,7 @@ bool js_register_gfx_TextureBarrierInfo(se::Object* obj) // NOLINT(readability-i cls->defineProperty("discardContents", _SE(js_gfx_TextureBarrierInfo_get_discardContents), _SE(js_gfx_TextureBarrierInfo_set_discardContents)); cls->defineProperty("srcQueue", _SE(js_gfx_TextureBarrierInfo_get_srcQueue), _SE(js_gfx_TextureBarrierInfo_set_srcQueue)); cls->defineProperty("dstQueue", _SE(js_gfx_TextureBarrierInfo_get_dstQueue), _SE(js_gfx_TextureBarrierInfo_set_dstQueue)); + cls->defineFunction("copy", _SE(js_gfx_TextureBarrierInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_TextureBarrierInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -11274,6 +12240,28 @@ bool js_register_gfx_TextureBarrierInfo(se::Object* obj) // NOLINT(readability-i se::Object* __jsb_cc_gfx_FramebufferInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_FramebufferInfo_class = nullptr; // NOLINT +static bool js_gfx_FramebufferInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_FramebufferInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_FramebufferInfo_copy : Error processing arguments"); + cc::gfx::FramebufferInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_FramebufferInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_FramebufferInfo_copy) + static bool js_gfx_FramebufferInfo_get_renderPass(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -11448,6 +12436,7 @@ bool js_register_gfx_FramebufferInfo(se::Object* obj) // NOLINT(readability-iden cls->defineProperty("renderPass", _SE(js_gfx_FramebufferInfo_get_renderPass), _SE(js_gfx_FramebufferInfo_set_renderPass)); cls->defineProperty("colorTextures", _SE(js_gfx_FramebufferInfo_get_colorTextures), _SE(js_gfx_FramebufferInfo_set_colorTextures)); cls->defineProperty("depthStencilTexture", _SE(js_gfx_FramebufferInfo_get_depthStencilTexture), _SE(js_gfx_FramebufferInfo_set_depthStencilTexture)); + cls->defineFunction("copy", _SE(js_gfx_FramebufferInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_FramebufferInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -11462,6 +12451,28 @@ bool js_register_gfx_FramebufferInfo(se::Object* obj) // NOLINT(readability-iden se::Object* __jsb_cc_gfx_DescriptorSetLayoutBinding_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_DescriptorSetLayoutBinding_class = nullptr; // NOLINT +static bool js_gfx_DescriptorSetLayoutBinding_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_DescriptorSetLayoutBinding_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSetLayoutBinding_copy : Error processing arguments"); + cc::gfx::DescriptorSetLayoutBinding& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSetLayoutBinding_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_DescriptorSetLayoutBinding_copy) + static bool js_gfx_DescriptorSetLayoutBinding_get_binding(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -11706,6 +12717,7 @@ bool js_register_gfx_DescriptorSetLayoutBinding(se::Object* obj) // NOLINT(reada cls->defineProperty("count", _SE(js_gfx_DescriptorSetLayoutBinding_get_count), _SE(js_gfx_DescriptorSetLayoutBinding_set_count)); cls->defineProperty("stageFlags", _SE(js_gfx_DescriptorSetLayoutBinding_get_stageFlags), _SE(js_gfx_DescriptorSetLayoutBinding_set_stageFlags)); cls->defineProperty("immutableSamplers", _SE(js_gfx_DescriptorSetLayoutBinding_get_immutableSamplers), _SE(js_gfx_DescriptorSetLayoutBinding_set_immutableSamplers)); + cls->defineFunction("copy", _SE(js_gfx_DescriptorSetLayoutBinding_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_DescriptorSetLayoutBinding_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -11720,6 +12732,28 @@ bool js_register_gfx_DescriptorSetLayoutBinding(se::Object* obj) // NOLINT(reada se::Object* __jsb_cc_gfx_DescriptorSetLayoutInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_DescriptorSetLayoutInfo_class = nullptr; // NOLINT +static bool js_gfx_DescriptorSetLayoutInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_DescriptorSetLayoutInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSetLayoutInfo_copy : Error processing arguments"); + cc::gfx::DescriptorSetLayoutInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSetLayoutInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_DescriptorSetLayoutInfo_copy) + static bool js_gfx_DescriptorSetLayoutInfo_get_bindings(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -11808,6 +12842,7 @@ bool js_register_gfx_DescriptorSetLayoutInfo(se::Object* obj) // NOLINT(readabil auto* cls = se::Class::create("DescriptorSetLayoutInfo", obj, nullptr, _SE(js_gfx_DescriptorSetLayoutInfo_constructor)); cls->defineProperty("bindings", _SE(js_gfx_DescriptorSetLayoutInfo_get_bindings), _SE(js_gfx_DescriptorSetLayoutInfo_set_bindings)); + cls->defineFunction("copy", _SE(js_gfx_DescriptorSetLayoutInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_DescriptorSetLayoutInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -11822,6 +12857,28 @@ bool js_register_gfx_DescriptorSetLayoutInfo(se::Object* obj) // NOLINT(readabil se::Object* __jsb_cc_gfx_DescriptorSetInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_DescriptorSetInfo_class = nullptr; // NOLINT +static bool js_gfx_DescriptorSetInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_DescriptorSetInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSetInfo_copy : Error processing arguments"); + cc::gfx::DescriptorSetInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSetInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_DescriptorSetInfo_copy) + static bool js_gfx_DescriptorSetInfo_get_layout(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -11910,6 +12967,7 @@ bool js_register_gfx_DescriptorSetInfo(se::Object* obj) // NOLINT(readability-id auto* cls = se::Class::create("DescriptorSetInfo", obj, nullptr, _SE(js_gfx_DescriptorSetInfo_constructor)); cls->defineProperty("layout", _SE(js_gfx_DescriptorSetInfo_get_layout), _SE(js_gfx_DescriptorSetInfo_set_layout)); + cls->defineFunction("copy", _SE(js_gfx_DescriptorSetInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_DescriptorSetInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -11924,6 +12982,28 @@ bool js_register_gfx_DescriptorSetInfo(se::Object* obj) // NOLINT(readability-id se::Object* __jsb_cc_gfx_PipelineLayoutInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_PipelineLayoutInfo_class = nullptr; // NOLINT +static bool js_gfx_PipelineLayoutInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_PipelineLayoutInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_PipelineLayoutInfo_copy : Error processing arguments"); + cc::gfx::PipelineLayoutInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_PipelineLayoutInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_PipelineLayoutInfo_copy) + static bool js_gfx_PipelineLayoutInfo_get_setLayouts(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -12012,6 +13092,7 @@ bool js_register_gfx_PipelineLayoutInfo(se::Object* obj) // NOLINT(readability-i auto* cls = se::Class::create("PipelineLayoutInfo", obj, nullptr, _SE(js_gfx_PipelineLayoutInfo_constructor)); cls->defineProperty("setLayouts", _SE(js_gfx_PipelineLayoutInfo_get_setLayouts), _SE(js_gfx_PipelineLayoutInfo_set_setLayouts)); + cls->defineFunction("copy", _SE(js_gfx_PipelineLayoutInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_PipelineLayoutInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -12026,6 +13107,28 @@ bool js_register_gfx_PipelineLayoutInfo(se::Object* obj) // NOLINT(readability-i se::Object* __jsb_cc_gfx_InputState_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_InputState_class = nullptr; // NOLINT +static bool js_gfx_InputState_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_InputState_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_InputState_copy : Error processing arguments"); + cc::gfx::InputState& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_InputState_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_InputState_copy) + static bool js_gfx_InputState_get_attributes(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -12114,6 +13217,7 @@ bool js_register_gfx_InputState(se::Object* obj) // NOLINT(readability-identifie auto* cls = se::Class::create("InputState", obj, nullptr, _SE(js_gfx_InputState_constructor)); cls->defineProperty("attributes", _SE(js_gfx_InputState_get_attributes), _SE(js_gfx_InputState_set_attributes)); + cls->defineFunction("copy", _SE(js_gfx_InputState_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_InputState_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -12128,6 +13232,28 @@ bool js_register_gfx_InputState(se::Object* obj) // NOLINT(readability-identifie se::Object* __jsb_cc_gfx_RasterizerState_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_RasterizerState_class = nullptr; // NOLINT +static bool js_gfx_RasterizerState_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_RasterizerState_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_RasterizerState_copy : Error processing arguments"); + cc::gfx::RasterizerState& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_RasterizerState_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_RasterizerState_copy) + static bool js_gfx_RasterizerState_reset(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -12632,6 +13758,7 @@ bool js_register_gfx_RasterizerState(se::Object* obj) // NOLINT(readability-iden cls->defineProperty("isDepthClip", _SE(js_gfx_RasterizerState_get_isDepthClip), _SE(js_gfx_RasterizerState_set_isDepthClip)); cls->defineProperty("isMultisample", _SE(js_gfx_RasterizerState_get_isMultisample), _SE(js_gfx_RasterizerState_set_isMultisample)); cls->defineProperty("lineWidth", _SE(js_gfx_RasterizerState_get_lineWidth), _SE(js_gfx_RasterizerState_set_lineWidth)); + cls->defineFunction("copy", _SE(js_gfx_RasterizerState_copy)); cls->defineFunction("reset", _SE(js_gfx_RasterizerState_reset)); cls->defineFinalizeFunction(_SE(js_cc_gfx_RasterizerState_finalize)); cls->install(); @@ -12647,6 +13774,28 @@ bool js_register_gfx_RasterizerState(se::Object* obj) // NOLINT(readability-iden se::Object* __jsb_cc_gfx_DepthStencilState_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_DepthStencilState_class = nullptr; // NOLINT +static bool js_gfx_DepthStencilState_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_DepthStencilState_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_DepthStencilState_copy : Error processing arguments"); + cc::gfx::DepthStencilState& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_DepthStencilState_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_DepthStencilState_copy) + static bool js_gfx_DepthStencilState_reset(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -13396,6 +14545,7 @@ bool js_register_gfx_DepthStencilState(se::Object* obj) // NOLINT(readability-id cls->defineProperty("stencilZFailOpBack", _SE(js_gfx_DepthStencilState_get_stencilZFailOpBack), _SE(js_gfx_DepthStencilState_set_stencilZFailOpBack)); cls->defineProperty("stencilPassOpBack", _SE(js_gfx_DepthStencilState_get_stencilPassOpBack), _SE(js_gfx_DepthStencilState_set_stencilPassOpBack)); cls->defineProperty("stencilRefBack", _SE(js_gfx_DepthStencilState_get_stencilRefBack), _SE(js_gfx_DepthStencilState_set_stencilRefBack)); + cls->defineFunction("copy", _SE(js_gfx_DepthStencilState_copy)); cls->defineFunction("reset", _SE(js_gfx_DepthStencilState_reset)); cls->defineFinalizeFunction(_SE(js_cc_gfx_DepthStencilState_finalize)); cls->install(); @@ -13411,6 +14561,43 @@ bool js_register_gfx_DepthStencilState(se::Object* obj) // NOLINT(readability-id se::Object* __jsb_cc_gfx_BlendTarget_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_BlendTarget_class = nullptr; // NOLINT +static bool js_gfx_BlendTarget_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_BlendTarget_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_BlendTarget_copy : Error processing arguments"); + cc::gfx::BlendTarget& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_BlendTarget_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_BlendTarget_copy) + +static bool js_gfx_BlendTarget_reset(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_BlendTarget_reset : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + if (argc == 0) { + cobj->reset(); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; +} +SE_BIND_FUNC(js_gfx_BlendTarget_reset) + static bool js_gfx_BlendTarget_get_blend(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -13760,6 +14947,8 @@ bool js_register_gfx_BlendTarget(se::Object* obj) // NOLINT(readability-identifi cls->defineProperty("blendDstAlpha", _SE(js_gfx_BlendTarget_get_blendDstAlpha), _SE(js_gfx_BlendTarget_set_blendDstAlpha)); cls->defineProperty("blendAlphaEq", _SE(js_gfx_BlendTarget_get_blendAlphaEq), _SE(js_gfx_BlendTarget_set_blendAlphaEq)); cls->defineProperty("blendColorMask", _SE(js_gfx_BlendTarget_get_blendColorMask), _SE(js_gfx_BlendTarget_set_blendColorMask)); + cls->defineFunction("copy", _SE(js_gfx_BlendTarget_copy)); + cls->defineFunction("reset", _SE(js_gfx_BlendTarget_reset)); cls->defineFinalizeFunction(_SE(js_cc_gfx_BlendTarget_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -13774,6 +14963,28 @@ bool js_register_gfx_BlendTarget(se::Object* obj) // NOLINT(readability-identifi se::Object* __jsb_cc_gfx_BlendState_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_BlendState_class = nullptr; // NOLINT +static bool js_gfx_BlendState_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_BlendState_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_BlendState_copy : Error processing arguments"); + cc::gfx::BlendState& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_BlendState_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_BlendState_copy) + static bool js_gfx_BlendState_destroy(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -14034,6 +15245,7 @@ bool js_register_gfx_BlendState(se::Object* obj) // NOLINT(readability-identifie cls->defineProperty("isIndepend", _SE(js_gfx_BlendState_get_isIndepend), _SE(js_gfx_BlendState_set_isIndepend)); cls->defineProperty("blendColor", _SE(js_gfx_BlendState_get_blendColor), _SE(js_gfx_BlendState_set_blendColor)); cls->defineProperty("targets", _SE(js_gfx_BlendState_get_targets), _SE(js_gfx_BlendState_set_targets)); + cls->defineFunction("copy", _SE(js_gfx_BlendState_copy)); cls->defineFunction("destroy", _SE(js_gfx_BlendState_destroy)); cls->defineFunction("reset", _SE(js_gfx_BlendState_reset)); cls->defineFunction("setTarget", _SE(js_gfx_BlendState_setTarget)); @@ -14051,6 +15263,28 @@ bool js_register_gfx_BlendState(se::Object* obj) // NOLINT(readability-identifie se::Object* __jsb_cc_gfx_PipelineStateInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_PipelineStateInfo_class = nullptr; // NOLINT +static bool js_gfx_PipelineStateInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_PipelineStateInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_PipelineStateInfo_copy : Error processing arguments"); + cc::gfx::PipelineStateInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_PipelineStateInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_PipelineStateInfo_copy) + static bool js_gfx_PipelineStateInfo_get_shader(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -14505,6 +15739,7 @@ bool js_register_gfx_PipelineStateInfo(se::Object* obj) // NOLINT(readability-id cls->defineProperty("dynamicStates", _SE(js_gfx_PipelineStateInfo_get_dynamicStates), _SE(js_gfx_PipelineStateInfo_set_dynamicStates)); cls->defineProperty("bindPoint", _SE(js_gfx_PipelineStateInfo_get_bindPoint), _SE(js_gfx_PipelineStateInfo_set_bindPoint)); cls->defineProperty("subpass", _SE(js_gfx_PipelineStateInfo_get_subpass), _SE(js_gfx_PipelineStateInfo_set_subpass)); + cls->defineFunction("copy", _SE(js_gfx_PipelineStateInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_PipelineStateInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -14519,6 +15754,28 @@ bool js_register_gfx_PipelineStateInfo(se::Object* obj) // NOLINT(readability-id se::Object* __jsb_cc_gfx_CommandBufferInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_CommandBufferInfo_class = nullptr; // NOLINT +static bool js_gfx_CommandBufferInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_CommandBufferInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_CommandBufferInfo_copy : Error processing arguments"); + cc::gfx::CommandBufferInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_CommandBufferInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_CommandBufferInfo_copy) + static bool js_gfx_CommandBufferInfo_get_queue(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -14658,6 +15915,7 @@ bool js_register_gfx_CommandBufferInfo(se::Object* obj) // NOLINT(readability-id cls->defineProperty("queue", _SE(js_gfx_CommandBufferInfo_get_queue), _SE(js_gfx_CommandBufferInfo_set_queue)); cls->defineProperty("type", _SE(js_gfx_CommandBufferInfo_get_type), _SE(js_gfx_CommandBufferInfo_set_type)); + cls->defineFunction("copy", _SE(js_gfx_CommandBufferInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_CommandBufferInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -14672,6 +15930,28 @@ bool js_register_gfx_CommandBufferInfo(se::Object* obj) // NOLINT(readability-id se::Object* __jsb_cc_gfx_QueueInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_QueueInfo_class = nullptr; // NOLINT +static bool js_gfx_QueueInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_QueueInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_QueueInfo_copy : Error processing arguments"); + cc::gfx::QueueInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_QueueInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_QueueInfo_copy) + static bool js_gfx_QueueInfo_get_type(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -14760,6 +16040,7 @@ bool js_register_gfx_QueueInfo(se::Object* obj) // NOLINT(readability-identifier auto* cls = se::Class::create("QueueInfo", obj, nullptr, _SE(js_gfx_QueueInfo_constructor)); cls->defineProperty("type", _SE(js_gfx_QueueInfo_get_type), _SE(js_gfx_QueueInfo_set_type)); + cls->defineFunction("copy", _SE(js_gfx_QueueInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_QueueInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -14774,6 +16055,28 @@ bool js_register_gfx_QueueInfo(se::Object* obj) // NOLINT(readability-identifier se::Object* __jsb_cc_gfx_QueryPoolInfo_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_QueryPoolInfo_class = nullptr; // NOLINT +static bool js_gfx_QueryPoolInfo_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_QueryPoolInfo_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_QueryPoolInfo_copy : Error processing arguments"); + cc::gfx::QueryPoolInfo& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_QueryPoolInfo_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_QueryPoolInfo_copy) + static bool js_gfx_QueryPoolInfo_get_type(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -14948,6 +16251,7 @@ bool js_register_gfx_QueryPoolInfo(se::Object* obj) // NOLINT(readability-identi cls->defineProperty("type", _SE(js_gfx_QueryPoolInfo_get_type), _SE(js_gfx_QueryPoolInfo_set_type)); cls->defineProperty("maxQueryObjects", _SE(js_gfx_QueryPoolInfo_get_maxQueryObjects), _SE(js_gfx_QueryPoolInfo_set_maxQueryObjects)); cls->defineProperty("forceWait", _SE(js_gfx_QueryPoolInfo_get_forceWait), _SE(js_gfx_QueryPoolInfo_set_forceWait)); + cls->defineFunction("copy", _SE(js_gfx_QueryPoolInfo_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_QueryPoolInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -14962,6 +16266,28 @@ bool js_register_gfx_QueryPoolInfo(se::Object* obj) // NOLINT(readability-identi se::Object* __jsb_cc_gfx_MemoryStatus_proto = nullptr; // NOLINT se::Class* __jsb_cc_gfx_MemoryStatus_class = nullptr; // NOLINT +static bool js_gfx_MemoryStatus_copy(se::State& s) // NOLINT(readability-identifier-naming) +{ + auto* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_gfx_MemoryStatus_copy : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + HolderType arg0 = {}; + ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); + SE_PRECONDITION2(ok, false, "js_gfx_MemoryStatus_copy : Error processing arguments"); + cc::gfx::MemoryStatus& result = cobj->copy(arg0.value()); + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "js_gfx_MemoryStatus_copy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_gfx_MemoryStatus_copy) + static bool js_gfx_MemoryStatus_get_bufferSize(se::State& s) // NOLINT(readability-identifier-naming) { auto* cobj = SE_THIS_OBJECT(s); @@ -15101,6 +16427,7 @@ bool js_register_gfx_MemoryStatus(se::Object* obj) // NOLINT(readability-identif cls->defineProperty("bufferSize", _SE(js_gfx_MemoryStatus_get_bufferSize), _SE(js_gfx_MemoryStatus_set_bufferSize)); cls->defineProperty("textureSize", _SE(js_gfx_MemoryStatus_get_textureSize), _SE(js_gfx_MemoryStatus_set_textureSize)); + cls->defineFunction("copy", _SE(js_gfx_MemoryStatus_copy)); cls->defineFinalizeFunction(_SE(js_cc_gfx_MemoryStatus_finalize)); cls->install(); JSBClassType::registerClass(cls); diff --git a/native/cocos/bindings/auto/jsb_gfx_auto.h b/native/cocos/bindings/auto/jsb_gfx_auto.h index 7423703e20..c9a36fc6bd 100644 --- a/native/cocos/bindings/auto/jsb_gfx_auto.h +++ b/native/cocos/bindings/auto/jsb_gfx_auto.h @@ -119,6 +119,7 @@ bool js_register_cc_gfx_Size(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::Size *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_Size_copy); extern se::Object *__jsb_cc_gfx_DeviceCaps_proto; // NOLINT extern se::Class * __jsb_cc_gfx_DeviceCaps_class; // NOLINT @@ -127,6 +128,7 @@ bool js_register_cc_gfx_DeviceCaps(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::DeviceCaps *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_DeviceCaps_copy); extern se::Object *__jsb_cc_gfx_Offset_proto; // NOLINT extern se::Class * __jsb_cc_gfx_Offset_class; // NOLINT @@ -135,6 +137,7 @@ bool js_register_cc_gfx_Offset(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::Offset *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_Offset_copy); extern se::Object *__jsb_cc_gfx_Rect_proto; // NOLINT extern se::Class * __jsb_cc_gfx_Rect_class; // NOLINT @@ -143,6 +146,7 @@ bool js_register_cc_gfx_Rect(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::Rect *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_Rect_copy); extern se::Object *__jsb_cc_gfx_Extent_proto; // NOLINT extern se::Class * __jsb_cc_gfx_Extent_class; // NOLINT @@ -151,6 +155,7 @@ bool js_register_cc_gfx_Extent(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::Extent *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_Extent_copy); extern se::Object *__jsb_cc_gfx_TextureSubresLayers_proto; // NOLINT extern se::Class * __jsb_cc_gfx_TextureSubresLayers_class; // NOLINT @@ -159,6 +164,7 @@ bool js_register_cc_gfx_TextureSubresLayers(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::TextureSubresLayers *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_TextureSubresLayers_copy); extern se::Object *__jsb_cc_gfx_TextureSubresRange_proto; // NOLINT extern se::Class * __jsb_cc_gfx_TextureSubresRange_class; // NOLINT @@ -167,6 +173,7 @@ bool js_register_cc_gfx_TextureSubresRange(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::TextureSubresRange *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_TextureSubresRange_copy); extern se::Object *__jsb_cc_gfx_TextureCopy_proto; // NOLINT extern se::Class * __jsb_cc_gfx_TextureCopy_class; // NOLINT @@ -175,6 +182,7 @@ bool js_register_cc_gfx_TextureCopy(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::TextureCopy *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_TextureCopy_copy); extern se::Object *__jsb_cc_gfx_TextureBlit_proto; // NOLINT extern se::Class * __jsb_cc_gfx_TextureBlit_class; // NOLINT @@ -183,6 +191,7 @@ bool js_register_cc_gfx_TextureBlit(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::TextureBlit *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_TextureBlit_copy); extern se::Object *__jsb_cc_gfx_BufferTextureCopy_proto; // NOLINT extern se::Class * __jsb_cc_gfx_BufferTextureCopy_class; // NOLINT @@ -191,6 +200,7 @@ bool js_register_cc_gfx_BufferTextureCopy(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::BufferTextureCopy *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_BufferTextureCopy_copy); extern se::Object *__jsb_cc_gfx_Viewport_proto; // NOLINT extern se::Class * __jsb_cc_gfx_Viewport_class; // NOLINT @@ -199,6 +209,7 @@ bool js_register_cc_gfx_Viewport(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::Viewport *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_Viewport_copy); extern se::Object *__jsb_cc_gfx_Color_proto; // NOLINT extern se::Class * __jsb_cc_gfx_Color_class; // NOLINT @@ -207,6 +218,7 @@ bool js_register_cc_gfx_Color(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::Color *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_Color_copy); extern se::Object *__jsb_cc_gfx_BindingMappingInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_BindingMappingInfo_class; // NOLINT @@ -215,6 +227,7 @@ bool js_register_cc_gfx_BindingMappingInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::BindingMappingInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_BindingMappingInfo_copy); extern se::Object *__jsb_cc_gfx_SwapchainInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_SwapchainInfo_class; // NOLINT @@ -223,6 +236,7 @@ bool js_register_cc_gfx_SwapchainInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::SwapchainInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_SwapchainInfo_copy); extern se::Object *__jsb_cc_gfx_DeviceInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_DeviceInfo_class; // NOLINT @@ -231,6 +245,7 @@ bool js_register_cc_gfx_DeviceInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::DeviceInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_DeviceInfo_copy); extern se::Object *__jsb_cc_gfx_BufferInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_BufferInfo_class; // NOLINT @@ -239,6 +254,7 @@ bool js_register_cc_gfx_BufferInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::BufferInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_BufferInfo_copy); extern se::Object *__jsb_cc_gfx_BufferViewInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_BufferViewInfo_class; // NOLINT @@ -247,6 +263,7 @@ bool js_register_cc_gfx_BufferViewInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::BufferViewInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_BufferViewInfo_copy); extern se::Object *__jsb_cc_gfx_DrawInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_DrawInfo_class; // NOLINT @@ -255,6 +272,7 @@ bool js_register_cc_gfx_DrawInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::DrawInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_DrawInfo_copy); extern se::Object *__jsb_cc_gfx_DispatchInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_DispatchInfo_class; // NOLINT @@ -263,6 +281,7 @@ bool js_register_cc_gfx_DispatchInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::DispatchInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_DispatchInfo_copy); extern se::Object *__jsb_cc_gfx_IndirectBuffer_proto; // NOLINT extern se::Class * __jsb_cc_gfx_IndirectBuffer_class; // NOLINT @@ -271,6 +290,7 @@ bool js_register_cc_gfx_IndirectBuffer(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::IndirectBuffer *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_IndirectBuffer_copy); extern se::Object *__jsb_cc_gfx_TextureInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_TextureInfo_class; // NOLINT @@ -279,6 +299,7 @@ bool js_register_cc_gfx_TextureInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::TextureInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_TextureInfo_copy); extern se::Object *__jsb_cc_gfx_TextureViewInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_TextureViewInfo_class; // NOLINT @@ -287,6 +308,7 @@ bool js_register_cc_gfx_TextureViewInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::TextureViewInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_TextureViewInfo_copy); extern se::Object *__jsb_cc_gfx_SamplerInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_SamplerInfo_class; // NOLINT @@ -295,6 +317,7 @@ bool js_register_cc_gfx_SamplerInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::SamplerInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_SamplerInfo_copy); extern se::Object *__jsb_cc_gfx_Uniform_proto; // NOLINT extern se::Class * __jsb_cc_gfx_Uniform_class; // NOLINT @@ -303,6 +326,7 @@ bool js_register_cc_gfx_Uniform(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::Uniform *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_Uniform_copy); extern se::Object *__jsb_cc_gfx_UniformBlock_proto; // NOLINT extern se::Class * __jsb_cc_gfx_UniformBlock_class; // NOLINT @@ -311,6 +335,7 @@ bool js_register_cc_gfx_UniformBlock(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::UniformBlock *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_UniformBlock_copy); extern se::Object *__jsb_cc_gfx_UniformSamplerTexture_proto; // NOLINT extern se::Class * __jsb_cc_gfx_UniformSamplerTexture_class; // NOLINT @@ -319,6 +344,7 @@ bool js_register_cc_gfx_UniformSamplerTexture(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::UniformSamplerTexture *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_UniformSamplerTexture_copy); extern se::Object *__jsb_cc_gfx_UniformSampler_proto; // NOLINT extern se::Class * __jsb_cc_gfx_UniformSampler_class; // NOLINT @@ -327,6 +353,7 @@ bool js_register_cc_gfx_UniformSampler(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::UniformSampler *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_UniformSampler_copy); extern se::Object *__jsb_cc_gfx_UniformTexture_proto; // NOLINT extern se::Class * __jsb_cc_gfx_UniformTexture_class; // NOLINT @@ -335,6 +362,7 @@ bool js_register_cc_gfx_UniformTexture(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::UniformTexture *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_UniformTexture_copy); extern se::Object *__jsb_cc_gfx_UniformStorageImage_proto; // NOLINT extern se::Class * __jsb_cc_gfx_UniformStorageImage_class; // NOLINT @@ -343,6 +371,7 @@ bool js_register_cc_gfx_UniformStorageImage(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::UniformStorageImage *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_UniformStorageImage_copy); extern se::Object *__jsb_cc_gfx_UniformStorageBuffer_proto; // NOLINT extern se::Class * __jsb_cc_gfx_UniformStorageBuffer_class; // NOLINT @@ -351,6 +380,7 @@ bool js_register_cc_gfx_UniformStorageBuffer(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::UniformStorageBuffer *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_UniformStorageBuffer_copy); extern se::Object *__jsb_cc_gfx_UniformInputAttachment_proto; // NOLINT extern se::Class * __jsb_cc_gfx_UniformInputAttachment_class; // NOLINT @@ -359,6 +389,7 @@ bool js_register_cc_gfx_UniformInputAttachment(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::UniformInputAttachment *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_UniformInputAttachment_copy); extern se::Object *__jsb_cc_gfx_ShaderStage_proto; // NOLINT extern se::Class * __jsb_cc_gfx_ShaderStage_class; // NOLINT @@ -367,6 +398,7 @@ bool js_register_cc_gfx_ShaderStage(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::ShaderStage *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_ShaderStage_copy); extern se::Object *__jsb_cc_gfx_Attribute_proto; // NOLINT extern se::Class * __jsb_cc_gfx_Attribute_class; // NOLINT @@ -375,6 +407,7 @@ bool js_register_cc_gfx_Attribute(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::Attribute *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_Attribute_copy); extern se::Object *__jsb_cc_gfx_ShaderInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_ShaderInfo_class; // NOLINT @@ -383,6 +416,7 @@ bool js_register_cc_gfx_ShaderInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::ShaderInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_ShaderInfo_copy); extern se::Object *__jsb_cc_gfx_InputAssemblerInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_InputAssemblerInfo_class; // NOLINT @@ -391,6 +425,7 @@ bool js_register_cc_gfx_InputAssemblerInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::InputAssemblerInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_InputAssemblerInfo_copy); extern se::Object *__jsb_cc_gfx_ColorAttachment_proto; // NOLINT extern se::Class * __jsb_cc_gfx_ColorAttachment_class; // NOLINT @@ -399,6 +434,7 @@ bool js_register_cc_gfx_ColorAttachment(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::ColorAttachment *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_ColorAttachment_copy); extern se::Object *__jsb_cc_gfx_DepthStencilAttachment_proto; // NOLINT extern se::Class * __jsb_cc_gfx_DepthStencilAttachment_class; // NOLINT @@ -407,6 +443,7 @@ bool js_register_cc_gfx_DepthStencilAttachment(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::DepthStencilAttachment *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_DepthStencilAttachment_copy); extern se::Object *__jsb_cc_gfx_SubpassInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_SubpassInfo_class; // NOLINT @@ -415,6 +452,7 @@ bool js_register_cc_gfx_SubpassInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::SubpassInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_SubpassInfo_copy); extern se::Object *__jsb_cc_gfx_SubpassDependency_proto; // NOLINT extern se::Class * __jsb_cc_gfx_SubpassDependency_class; // NOLINT @@ -423,6 +461,7 @@ bool js_register_cc_gfx_SubpassDependency(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::SubpassDependency *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_SubpassDependency_copy); extern se::Object *__jsb_cc_gfx_RenderPassInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_RenderPassInfo_class; // NOLINT @@ -431,6 +470,7 @@ bool js_register_cc_gfx_RenderPassInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::RenderPassInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_RenderPassInfo_copy); extern se::Object *__jsb_cc_gfx_GeneralBarrierInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_GeneralBarrierInfo_class; // NOLINT @@ -439,6 +479,7 @@ bool js_register_cc_gfx_GeneralBarrierInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::GeneralBarrierInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_GeneralBarrierInfo_copy); extern se::Object *__jsb_cc_gfx_TextureBarrierInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_TextureBarrierInfo_class; // NOLINT @@ -447,6 +488,7 @@ bool js_register_cc_gfx_TextureBarrierInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::TextureBarrierInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_TextureBarrierInfo_copy); extern se::Object *__jsb_cc_gfx_FramebufferInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_FramebufferInfo_class; // NOLINT @@ -455,6 +497,7 @@ bool js_register_cc_gfx_FramebufferInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::FramebufferInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_FramebufferInfo_copy); extern se::Object *__jsb_cc_gfx_DescriptorSetLayoutBinding_proto; // NOLINT extern se::Class * __jsb_cc_gfx_DescriptorSetLayoutBinding_class; // NOLINT @@ -463,6 +506,7 @@ bool js_register_cc_gfx_DescriptorSetLayoutBinding(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::DescriptorSetLayoutBinding *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_DescriptorSetLayoutBinding_copy); extern se::Object *__jsb_cc_gfx_DescriptorSetLayoutInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_DescriptorSetLayoutInfo_class; // NOLINT @@ -471,6 +515,7 @@ bool js_register_cc_gfx_DescriptorSetLayoutInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::DescriptorSetLayoutInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_DescriptorSetLayoutInfo_copy); extern se::Object *__jsb_cc_gfx_DescriptorSetInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_DescriptorSetInfo_class; // NOLINT @@ -479,6 +524,7 @@ bool js_register_cc_gfx_DescriptorSetInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::DescriptorSetInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_DescriptorSetInfo_copy); extern se::Object *__jsb_cc_gfx_PipelineLayoutInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_PipelineLayoutInfo_class; // NOLINT @@ -487,6 +533,7 @@ bool js_register_cc_gfx_PipelineLayoutInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::PipelineLayoutInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_PipelineLayoutInfo_copy); extern se::Object *__jsb_cc_gfx_InputState_proto; // NOLINT extern se::Class * __jsb_cc_gfx_InputState_class; // NOLINT @@ -495,6 +542,7 @@ bool js_register_cc_gfx_InputState(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::InputState *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_InputState_copy); extern se::Object *__jsb_cc_gfx_RasterizerState_proto; // NOLINT extern se::Class * __jsb_cc_gfx_RasterizerState_class; // NOLINT @@ -503,6 +551,7 @@ bool js_register_cc_gfx_RasterizerState(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::RasterizerState *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_RasterizerState_copy); SE_DECLARE_FUNC(js_gfx_RasterizerState_reset); extern se::Object *__jsb_cc_gfx_DepthStencilState_proto; // NOLINT @@ -512,6 +561,7 @@ bool js_register_cc_gfx_DepthStencilState(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::DepthStencilState *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_DepthStencilState_copy); SE_DECLARE_FUNC(js_gfx_DepthStencilState_reset); extern se::Object *__jsb_cc_gfx_BlendTarget_proto; // NOLINT @@ -521,6 +571,8 @@ bool js_register_cc_gfx_BlendTarget(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::BlendTarget *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_BlendTarget_copy); +SE_DECLARE_FUNC(js_gfx_BlendTarget_reset); extern se::Object *__jsb_cc_gfx_BlendState_proto; // NOLINT extern se::Class * __jsb_cc_gfx_BlendState_class; // NOLINT @@ -529,6 +581,7 @@ bool js_register_cc_gfx_BlendState(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::BlendState *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_BlendState_copy); SE_DECLARE_FUNC(js_gfx_BlendState_destroy); SE_DECLARE_FUNC(js_gfx_BlendState_reset); SE_DECLARE_FUNC(js_gfx_BlendState_setTarget); @@ -540,6 +593,7 @@ bool js_register_cc_gfx_PipelineStateInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::PipelineStateInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_PipelineStateInfo_copy); extern se::Object *__jsb_cc_gfx_CommandBufferInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_CommandBufferInfo_class; // NOLINT @@ -548,6 +602,7 @@ bool js_register_cc_gfx_CommandBufferInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::CommandBufferInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_CommandBufferInfo_copy); extern se::Object *__jsb_cc_gfx_QueueInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_QueueInfo_class; // NOLINT @@ -556,6 +611,7 @@ bool js_register_cc_gfx_QueueInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::QueueInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_QueueInfo_copy); extern se::Object *__jsb_cc_gfx_QueryPoolInfo_proto; // NOLINT extern se::Class * __jsb_cc_gfx_QueryPoolInfo_class; // NOLINT @@ -564,6 +620,7 @@ bool js_register_cc_gfx_QueryPoolInfo(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::QueryPoolInfo *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_QueryPoolInfo_copy); extern se::Object *__jsb_cc_gfx_MemoryStatus_proto; // NOLINT extern se::Class * __jsb_cc_gfx_MemoryStatus_class; // NOLINT @@ -572,6 +629,7 @@ bool js_register_cc_gfx_MemoryStatus(se::Object *obj); // NOLINT template <> bool sevalue_to_native(const se::Value &, cc::gfx::MemoryStatus *, se::Object *ctx); //NOLINT +SE_DECLARE_FUNC(js_gfx_MemoryStatus_copy); extern se::Object *__jsb_cc_gfx_GFXObject_proto; // NOLINT extern se::Class * __jsb_cc_gfx_GFXObject_class; // NOLINT