From de5c457ef1edf1fadb9e73c58efd0da79bf29a02 Mon Sep 17 00:00:00 2001 From: qubka Date: Tue, 2 Dec 2025 10:33:31 +0000 Subject: [PATCH 1/6] fix: add try catch to legacy parser --- parser/parser_deprecated.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/parser/parser_deprecated.py b/parser/parser_deprecated.py index 30846a9..338147f 100644 --- a/parser/parser_deprecated.py +++ b/parser/parser_deprecated.py @@ -313,7 +313,10 @@ def main(input_folder, output_file): file_contents = remove_specific_lines(file.read()) contents = file_contents.replace('extern "C"', '').replace('PLUGIN_API', '') file_name = os.path.splitext(os.path.basename(cpp_file))[0] - parsed = simple.parse_string(contents, options=None) + try: + parsed = simple.parse_string(contents, options=None) + except: + pass exported_methods = process_functions(parsed, file_name, file_contents) all_exported_methods.extend(exported_methods) From c2d9034c6455f48006f97de110d581da03e19603 Mon Sep 17 00:00:00 2001 From: qubka Date: Wed, 10 Dec 2025 00:09:13 +0000 Subject: [PATCH 2/6] docs: update readme --- README.md | 4 ++++ README_ru.md | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/README.md b/README.md index bbce77c..cfaab97 100644 --- a/README.md +++ b/README.md @@ -91,6 +91,10 @@ public: std::cout << "Example Start!" << std::endl; } + void OnPluginUpdate() override { + std::cout << "Example Update!" << std::endl; + } + void OnPluginEnd() override { std::cout << "Example End!" << std::endl; } diff --git a/README_ru.md b/README_ru.md index 28e9115..008341f 100644 --- a/README_ru.md +++ b/README_ru.md @@ -91,6 +91,10 @@ public: std::cout << "Example Start!" << std::endl; } + void OnPluginUpdate() override { + std::cout << "Example Update!" << std::endl; + } + void OnPluginEnd() override { std::cout << "Example End!" << std::endl; } From ab8aa8168b8c981aa54cd38f7a95c6cdc4b04777 Mon Sep 17 00:00:00 2001 From: qubka Date: Sat, 13 Dec 2025 14:06:19 +0000 Subject: [PATCH 3/6] fix: update tests --- test/cross_call_master/CMakeLists.txt | 2 +- .../cross_call_worker/cross_call_worker.cpp | 292 ++ .../cross_call_worker/cross_call_worker.hpp | 8 + .../cross_call_worker/core.hpp | 1802 ++++++++++ .../cross_call_worker/delegates.hpp | 165 + .../cross_call_worker/enums.hpp | 19 + .../external/plugify/include/plg/plugin.hpp | 19 +- .../plugify/include/pps/cross_call_worker.hpp | 3161 ----------------- test/cross_call_master/plugin.cpp | 2 +- test/cross_call_worker/CMakeLists.txt | 2 +- .../cross_call_master/cross_call_master.cpp | 340 ++ .../cross_call_master/cross_call_master.hpp | 10 + .../cross_call_master/core.hpp | 2086 +++++++++++ .../cross_call_master/counter.hpp | 140 + .../cross_call_master/delegates.hpp | 165 + .../cross_call_master/enums.hpp | 19 + .../cross_call_master/resource.hpp | 162 + .../external/plugify/include/plg/plugin.hpp | 19 +- .../plugify/include/pps/cross_call_master.hpp | 2531 ------------- test/cross_call_worker/plugin.cpp | 8 +- .../external/plugify/include/plg/plugin.hpp | 19 +- 21 files changed, 5236 insertions(+), 5735 deletions(-) create mode 100644 test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker.cpp create mode 100644 test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker.hpp create mode 100644 test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker/core.hpp create mode 100644 test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker/delegates.hpp create mode 100644 test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker/enums.hpp delete mode 100644 test/cross_call_master/external/plugify/include/pps/cross_call_worker.hpp create mode 100644 test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master.cpp create mode 100644 test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master.hpp create mode 100644 test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/core.hpp create mode 100644 test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/counter.hpp create mode 100644 test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/delegates.hpp create mode 100644 test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/enums.hpp create mode 100644 test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/resource.hpp delete mode 100644 test/cross_call_worker/external/plugify/include/pps/cross_call_master.hpp diff --git a/test/cross_call_master/CMakeLists.txt b/test/cross_call_master/CMakeLists.txt index 729339a..52d2d27 100644 --- a/test/cross_call_master/CMakeLists.txt +++ b/test/cross_call_master/CMakeLists.txt @@ -30,7 +30,7 @@ include(cmake/CompatFormat.cmake) # # Plugin # -set(PLUGIN_SOURCES "plugin.cpp" "simple_tests.hpp" "simple_tests.cpp") +set(PLUGIN_SOURCES "plugin.cpp" "simple_tests.hpp" "simple_tests.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/external/plugify/include/cross_call_worker/cross_call_worker.cpp") add_library(${PROJECT_NAME} SHARED ${PLUGIN_SOURCES}) target_include_directories(${PROJECT_NAME} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/external/plugify/include") diff --git a/test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker.cpp b/test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker.cpp new file mode 100644 index 0000000..58817be --- /dev/null +++ b/test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker.cpp @@ -0,0 +1,292 @@ +#include "cross_call_worker.hpp" + +cross_call_worker::_NoParamReturnVoid __cross_call_worker_NoParamReturnVoid = nullptr; + +cross_call_worker::_NoParamReturnBool __cross_call_worker_NoParamReturnBool = nullptr; + +cross_call_worker::_NoParamReturnChar8 __cross_call_worker_NoParamReturnChar8 = nullptr; + +cross_call_worker::_NoParamReturnChar16 __cross_call_worker_NoParamReturnChar16 = nullptr; + +cross_call_worker::_NoParamReturnInt8 __cross_call_worker_NoParamReturnInt8 = nullptr; + +cross_call_worker::_NoParamReturnInt16 __cross_call_worker_NoParamReturnInt16 = nullptr; + +cross_call_worker::_NoParamReturnInt32 __cross_call_worker_NoParamReturnInt32 = nullptr; + +cross_call_worker::_NoParamReturnInt64 __cross_call_worker_NoParamReturnInt64 = nullptr; + +cross_call_worker::_NoParamReturnUInt8 __cross_call_worker_NoParamReturnUInt8 = nullptr; + +cross_call_worker::_NoParamReturnUInt16 __cross_call_worker_NoParamReturnUInt16 = nullptr; + +cross_call_worker::_NoParamReturnUInt32 __cross_call_worker_NoParamReturnUInt32 = nullptr; + +cross_call_worker::_NoParamReturnUInt64 __cross_call_worker_NoParamReturnUInt64 = nullptr; + +cross_call_worker::_NoParamReturnPointer __cross_call_worker_NoParamReturnPointer = nullptr; + +cross_call_worker::_NoParamReturnFloat __cross_call_worker_NoParamReturnFloat = nullptr; + +cross_call_worker::_NoParamReturnDouble __cross_call_worker_NoParamReturnDouble = nullptr; + +cross_call_worker::_NoParamReturnFunction __cross_call_worker_NoParamReturnFunction = nullptr; + +cross_call_worker::_NoParamReturnString __cross_call_worker_NoParamReturnString = nullptr; + +cross_call_worker::_NoParamReturnAny __cross_call_worker_NoParamReturnAny = nullptr; + +cross_call_worker::_NoParamReturnArrayBool __cross_call_worker_NoParamReturnArrayBool = nullptr; + +cross_call_worker::_NoParamReturnArrayChar8 __cross_call_worker_NoParamReturnArrayChar8 = nullptr; + +cross_call_worker::_NoParamReturnArrayChar16 __cross_call_worker_NoParamReturnArrayChar16 = nullptr; + +cross_call_worker::_NoParamReturnArrayInt8 __cross_call_worker_NoParamReturnArrayInt8 = nullptr; + +cross_call_worker::_NoParamReturnArrayInt16 __cross_call_worker_NoParamReturnArrayInt16 = nullptr; + +cross_call_worker::_NoParamReturnArrayInt32 __cross_call_worker_NoParamReturnArrayInt32 = nullptr; + +cross_call_worker::_NoParamReturnArrayInt64 __cross_call_worker_NoParamReturnArrayInt64 = nullptr; + +cross_call_worker::_NoParamReturnArrayUInt8 __cross_call_worker_NoParamReturnArrayUInt8 = nullptr; + +cross_call_worker::_NoParamReturnArrayUInt16 __cross_call_worker_NoParamReturnArrayUInt16 = nullptr; + +cross_call_worker::_NoParamReturnArrayUInt32 __cross_call_worker_NoParamReturnArrayUInt32 = nullptr; + +cross_call_worker::_NoParamReturnArrayUInt64 __cross_call_worker_NoParamReturnArrayUInt64 = nullptr; + +cross_call_worker::_NoParamReturnArrayPointer __cross_call_worker_NoParamReturnArrayPointer = nullptr; + +cross_call_worker::_NoParamReturnArrayFloat __cross_call_worker_NoParamReturnArrayFloat = nullptr; + +cross_call_worker::_NoParamReturnArrayDouble __cross_call_worker_NoParamReturnArrayDouble = nullptr; + +cross_call_worker::_NoParamReturnArrayString __cross_call_worker_NoParamReturnArrayString = nullptr; + +cross_call_worker::_NoParamReturnArrayAny __cross_call_worker_NoParamReturnArrayAny = nullptr; + +cross_call_worker::_NoParamReturnArrayVector2 __cross_call_worker_NoParamReturnArrayVector2 = nullptr; + +cross_call_worker::_NoParamReturnArrayVector3 __cross_call_worker_NoParamReturnArrayVector3 = nullptr; + +cross_call_worker::_NoParamReturnArrayVector4 __cross_call_worker_NoParamReturnArrayVector4 = nullptr; + +cross_call_worker::_NoParamReturnArrayMatrix4x4 __cross_call_worker_NoParamReturnArrayMatrix4x4 = nullptr; + +cross_call_worker::_NoParamReturnVector2 __cross_call_worker_NoParamReturnVector2 = nullptr; + +cross_call_worker::_NoParamReturnVector3 __cross_call_worker_NoParamReturnVector3 = nullptr; + +cross_call_worker::_NoParamReturnVector4 __cross_call_worker_NoParamReturnVector4 = nullptr; + +cross_call_worker::_NoParamReturnMatrix4x4 __cross_call_worker_NoParamReturnMatrix4x4 = nullptr; + +cross_call_worker::_Param1 __cross_call_worker_Param1 = nullptr; + +cross_call_worker::_Param2 __cross_call_worker_Param2 = nullptr; + +cross_call_worker::_Param3 __cross_call_worker_Param3 = nullptr; + +cross_call_worker::_Param4 __cross_call_worker_Param4 = nullptr; + +cross_call_worker::_Param5 __cross_call_worker_Param5 = nullptr; + +cross_call_worker::_Param6 __cross_call_worker_Param6 = nullptr; + +cross_call_worker::_Param7 __cross_call_worker_Param7 = nullptr; + +cross_call_worker::_Param8 __cross_call_worker_Param8 = nullptr; + +cross_call_worker::_Param9 __cross_call_worker_Param9 = nullptr; + +cross_call_worker::_Param10 __cross_call_worker_Param10 = nullptr; + +cross_call_worker::_ParamRef1 __cross_call_worker_ParamRef1 = nullptr; + +cross_call_worker::_ParamRef2 __cross_call_worker_ParamRef2 = nullptr; + +cross_call_worker::_ParamRef3 __cross_call_worker_ParamRef3 = nullptr; + +cross_call_worker::_ParamRef4 __cross_call_worker_ParamRef4 = nullptr; + +cross_call_worker::_ParamRef5 __cross_call_worker_ParamRef5 = nullptr; + +cross_call_worker::_ParamRef6 __cross_call_worker_ParamRef6 = nullptr; + +cross_call_worker::_ParamRef7 __cross_call_worker_ParamRef7 = nullptr; + +cross_call_worker::_ParamRef8 __cross_call_worker_ParamRef8 = nullptr; + +cross_call_worker::_ParamRef9 __cross_call_worker_ParamRef9 = nullptr; + +cross_call_worker::_ParamRef10 __cross_call_worker_ParamRef10 = nullptr; + +cross_call_worker::_ParamRefVectors __cross_call_worker_ParamRefVectors = nullptr; + +cross_call_worker::_ParamAllPrimitives __cross_call_worker_ParamAllPrimitives = nullptr; + +cross_call_worker::_ParamVariant __cross_call_worker_ParamVariant = nullptr; + +cross_call_worker::_ParamEnum __cross_call_worker_ParamEnum = nullptr; + +cross_call_worker::_ParamEnumRef __cross_call_worker_ParamEnumRef = nullptr; + +cross_call_worker::_ParamVariantRef __cross_call_worker_ParamVariantRef = nullptr; + +cross_call_worker::_CallFuncVoid __cross_call_worker_CallFuncVoid = nullptr; + +cross_call_worker::_CallFuncBool __cross_call_worker_CallFuncBool = nullptr; + +cross_call_worker::_CallFuncChar8 __cross_call_worker_CallFuncChar8 = nullptr; + +cross_call_worker::_CallFuncChar16 __cross_call_worker_CallFuncChar16 = nullptr; + +cross_call_worker::_CallFuncInt8 __cross_call_worker_CallFuncInt8 = nullptr; + +cross_call_worker::_CallFuncInt16 __cross_call_worker_CallFuncInt16 = nullptr; + +cross_call_worker::_CallFuncInt32 __cross_call_worker_CallFuncInt32 = nullptr; + +cross_call_worker::_CallFuncInt64 __cross_call_worker_CallFuncInt64 = nullptr; + +cross_call_worker::_CallFuncUInt8 __cross_call_worker_CallFuncUInt8 = nullptr; + +cross_call_worker::_CallFuncUInt16 __cross_call_worker_CallFuncUInt16 = nullptr; + +cross_call_worker::_CallFuncUInt32 __cross_call_worker_CallFuncUInt32 = nullptr; + +cross_call_worker::_CallFuncUInt64 __cross_call_worker_CallFuncUInt64 = nullptr; + +cross_call_worker::_CallFuncPtr __cross_call_worker_CallFuncPtr = nullptr; + +cross_call_worker::_CallFuncFloat __cross_call_worker_CallFuncFloat = nullptr; + +cross_call_worker::_CallFuncDouble __cross_call_worker_CallFuncDouble = nullptr; + +cross_call_worker::_CallFuncString __cross_call_worker_CallFuncString = nullptr; + +cross_call_worker::_CallFuncAny __cross_call_worker_CallFuncAny = nullptr; + +cross_call_worker::_CallFuncFunction __cross_call_worker_CallFuncFunction = nullptr; + +cross_call_worker::_CallFuncBoolVector __cross_call_worker_CallFuncBoolVector = nullptr; + +cross_call_worker::_CallFuncChar8Vector __cross_call_worker_CallFuncChar8Vector = nullptr; + +cross_call_worker::_CallFuncChar16Vector __cross_call_worker_CallFuncChar16Vector = nullptr; + +cross_call_worker::_CallFuncInt8Vector __cross_call_worker_CallFuncInt8Vector = nullptr; + +cross_call_worker::_CallFuncInt16Vector __cross_call_worker_CallFuncInt16Vector = nullptr; + +cross_call_worker::_CallFuncInt32Vector __cross_call_worker_CallFuncInt32Vector = nullptr; + +cross_call_worker::_CallFuncInt64Vector __cross_call_worker_CallFuncInt64Vector = nullptr; + +cross_call_worker::_CallFuncUInt8Vector __cross_call_worker_CallFuncUInt8Vector = nullptr; + +cross_call_worker::_CallFuncUInt16Vector __cross_call_worker_CallFuncUInt16Vector = nullptr; + +cross_call_worker::_CallFuncUInt32Vector __cross_call_worker_CallFuncUInt32Vector = nullptr; + +cross_call_worker::_CallFuncUInt64Vector __cross_call_worker_CallFuncUInt64Vector = nullptr; + +cross_call_worker::_CallFuncPtrVector __cross_call_worker_CallFuncPtrVector = nullptr; + +cross_call_worker::_CallFuncFloatVector __cross_call_worker_CallFuncFloatVector = nullptr; + +cross_call_worker::_CallFuncDoubleVector __cross_call_worker_CallFuncDoubleVector = nullptr; + +cross_call_worker::_CallFuncStringVector __cross_call_worker_CallFuncStringVector = nullptr; + +cross_call_worker::_CallFuncAnyVector __cross_call_worker_CallFuncAnyVector = nullptr; + +cross_call_worker::_CallFuncVec2Vector __cross_call_worker_CallFuncVec2Vector = nullptr; + +cross_call_worker::_CallFuncVec3Vector __cross_call_worker_CallFuncVec3Vector = nullptr; + +cross_call_worker::_CallFuncVec4Vector __cross_call_worker_CallFuncVec4Vector = nullptr; + +cross_call_worker::_CallFuncMat4x4Vector __cross_call_worker_CallFuncMat4x4Vector = nullptr; + +cross_call_worker::_CallFuncVec2 __cross_call_worker_CallFuncVec2 = nullptr; + +cross_call_worker::_CallFuncVec3 __cross_call_worker_CallFuncVec3 = nullptr; + +cross_call_worker::_CallFuncVec4 __cross_call_worker_CallFuncVec4 = nullptr; + +cross_call_worker::_CallFuncMat4x4 __cross_call_worker_CallFuncMat4x4 = nullptr; + +cross_call_worker::_CallFunc1 __cross_call_worker_CallFunc1 = nullptr; + +cross_call_worker::_CallFunc2 __cross_call_worker_CallFunc2 = nullptr; + +cross_call_worker::_CallFunc3 __cross_call_worker_CallFunc3 = nullptr; + +cross_call_worker::_CallFunc4 __cross_call_worker_CallFunc4 = nullptr; + +cross_call_worker::_CallFunc5 __cross_call_worker_CallFunc5 = nullptr; + +cross_call_worker::_CallFunc6 __cross_call_worker_CallFunc6 = nullptr; + +cross_call_worker::_CallFunc7 __cross_call_worker_CallFunc7 = nullptr; + +cross_call_worker::_CallFunc8 __cross_call_worker_CallFunc8 = nullptr; + +cross_call_worker::_CallFunc9 __cross_call_worker_CallFunc9 = nullptr; + +cross_call_worker::_CallFunc10 __cross_call_worker_CallFunc10 = nullptr; + +cross_call_worker::_CallFunc11 __cross_call_worker_CallFunc11 = nullptr; + +cross_call_worker::_CallFunc12 __cross_call_worker_CallFunc12 = nullptr; + +cross_call_worker::_CallFunc13 __cross_call_worker_CallFunc13 = nullptr; + +cross_call_worker::_CallFunc14 __cross_call_worker_CallFunc14 = nullptr; + +cross_call_worker::_CallFunc15 __cross_call_worker_CallFunc15 = nullptr; + +cross_call_worker::_CallFunc16 __cross_call_worker_CallFunc16 = nullptr; + +cross_call_worker::_CallFunc17 __cross_call_worker_CallFunc17 = nullptr; + +cross_call_worker::_CallFunc18 __cross_call_worker_CallFunc18 = nullptr; + +cross_call_worker::_CallFunc19 __cross_call_worker_CallFunc19 = nullptr; + +cross_call_worker::_CallFunc20 __cross_call_worker_CallFunc20 = nullptr; + +cross_call_worker::_CallFunc21 __cross_call_worker_CallFunc21 = nullptr; + +cross_call_worker::_CallFunc22 __cross_call_worker_CallFunc22 = nullptr; + +cross_call_worker::_CallFunc23 __cross_call_worker_CallFunc23 = nullptr; + +cross_call_worker::_CallFunc24 __cross_call_worker_CallFunc24 = nullptr; + +cross_call_worker::_CallFunc25 __cross_call_worker_CallFunc25 = nullptr; + +cross_call_worker::_CallFunc26 __cross_call_worker_CallFunc26 = nullptr; + +cross_call_worker::_CallFunc27 __cross_call_worker_CallFunc27 = nullptr; + +cross_call_worker::_CallFunc28 __cross_call_worker_CallFunc28 = nullptr; + +cross_call_worker::_CallFunc29 __cross_call_worker_CallFunc29 = nullptr; + +cross_call_worker::_CallFunc30 __cross_call_worker_CallFunc30 = nullptr; + +cross_call_worker::_CallFunc31 __cross_call_worker_CallFunc31 = nullptr; + +cross_call_worker::_CallFunc32 __cross_call_worker_CallFunc32 = nullptr; + +cross_call_worker::_CallFunc33 __cross_call_worker_CallFunc33 = nullptr; + +cross_call_worker::_CallFuncEnum __cross_call_worker_CallFuncEnum = nullptr; + +cross_call_worker::_ReverseCall __cross_call_worker_ReverseCall = nullptr; + diff --git a/test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker.hpp b/test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker.hpp new file mode 100644 index 0000000..9ec6db9 --- /dev/null +++ b/test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker.hpp @@ -0,0 +1,8 @@ +#pragma once + +// Generated from cross_call_worker.pplugin +// This header includes all generated components + +#include "cross_call_worker/enums.hpp" +#include "cross_call_worker/delegates.hpp" +#include "cross_call_worker/core.hpp" diff --git a/test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker/core.hpp b/test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker/core.hpp new file mode 100644 index 0000000..ed103f1 --- /dev/null +++ b/test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker/core.hpp @@ -0,0 +1,1802 @@ +#pragma once + +#include + +#include "enums.hpp" +#include "delegates.hpp" +// Generated from cross_call_worker.pplugin (group: core) + +namespace cross_call_worker { + + using _NoParamReturnVoid = void (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnVoid __cross_call_worker_NoParamReturnVoid; +namespace cross_call_worker { + /** + */ + inline void NoParamReturnVoid() { + return __cross_call_worker_NoParamReturnVoid(); + } + + using _NoParamReturnBool = bool (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnBool __cross_call_worker_NoParamReturnBool; +namespace cross_call_worker { + /** + * @return bool + */ + inline bool NoParamReturnBool() { + return __cross_call_worker_NoParamReturnBool(); + } + + using _NoParamReturnChar8 = char (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnChar8 __cross_call_worker_NoParamReturnChar8; +namespace cross_call_worker { + /** + * @return char8 + */ + inline char NoParamReturnChar8() { + return __cross_call_worker_NoParamReturnChar8(); + } + + using _NoParamReturnChar16 = char16_t (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnChar16 __cross_call_worker_NoParamReturnChar16; +namespace cross_call_worker { + /** + * @return char16 + */ + inline char16_t NoParamReturnChar16() { + return __cross_call_worker_NoParamReturnChar16(); + } + + using _NoParamReturnInt8 = int8_t (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnInt8 __cross_call_worker_NoParamReturnInt8; +namespace cross_call_worker { + /** + * @return int8 + */ + inline int8_t NoParamReturnInt8() { + return __cross_call_worker_NoParamReturnInt8(); + } + + using _NoParamReturnInt16 = int16_t (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnInt16 __cross_call_worker_NoParamReturnInt16; +namespace cross_call_worker { + /** + * @return int16 + */ + inline int16_t NoParamReturnInt16() { + return __cross_call_worker_NoParamReturnInt16(); + } + + using _NoParamReturnInt32 = int32_t (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnInt32 __cross_call_worker_NoParamReturnInt32; +namespace cross_call_worker { + /** + * @return int32 + */ + inline int32_t NoParamReturnInt32() { + return __cross_call_worker_NoParamReturnInt32(); + } + + using _NoParamReturnInt64 = int64_t (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnInt64 __cross_call_worker_NoParamReturnInt64; +namespace cross_call_worker { + /** + * @return int64 + */ + inline int64_t NoParamReturnInt64() { + return __cross_call_worker_NoParamReturnInt64(); + } + + using _NoParamReturnUInt8 = uint8_t (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnUInt8 __cross_call_worker_NoParamReturnUInt8; +namespace cross_call_worker { + /** + * @return uint8 + */ + inline uint8_t NoParamReturnUInt8() { + return __cross_call_worker_NoParamReturnUInt8(); + } + + using _NoParamReturnUInt16 = uint16_t (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnUInt16 __cross_call_worker_NoParamReturnUInt16; +namespace cross_call_worker { + /** + * @return uint16 + */ + inline uint16_t NoParamReturnUInt16() { + return __cross_call_worker_NoParamReturnUInt16(); + } + + using _NoParamReturnUInt32 = uint32_t (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnUInt32 __cross_call_worker_NoParamReturnUInt32; +namespace cross_call_worker { + /** + * @return uint32 + */ + inline uint32_t NoParamReturnUInt32() { + return __cross_call_worker_NoParamReturnUInt32(); + } + + using _NoParamReturnUInt64 = uint64_t (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnUInt64 __cross_call_worker_NoParamReturnUInt64; +namespace cross_call_worker { + /** + * @return uint64 + */ + inline uint64_t NoParamReturnUInt64() { + return __cross_call_worker_NoParamReturnUInt64(); + } + + using _NoParamReturnPointer = void* (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnPointer __cross_call_worker_NoParamReturnPointer; +namespace cross_call_worker { + /** + * @return ptr64 + */ + inline void* NoParamReturnPointer() { + return __cross_call_worker_NoParamReturnPointer(); + } + + using _NoParamReturnFloat = float (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnFloat __cross_call_worker_NoParamReturnFloat; +namespace cross_call_worker { + /** + * @return float + */ + inline float NoParamReturnFloat() { + return __cross_call_worker_NoParamReturnFloat(); + } + + using _NoParamReturnDouble = double (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnDouble __cross_call_worker_NoParamReturnDouble; +namespace cross_call_worker { + /** + * @return double + */ + inline double NoParamReturnDouble() { + return __cross_call_worker_NoParamReturnDouble(); + } + + using _NoParamReturnFunction = NoParamReturnFunctionFunc (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnFunction __cross_call_worker_NoParamReturnFunction; +namespace cross_call_worker { + /** + * @return function + */ + inline NoParamReturnFunctionFunc NoParamReturnFunction() { + return __cross_call_worker_NoParamReturnFunction(); + } + + using _NoParamReturnString = plg::string (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnString __cross_call_worker_NoParamReturnString; +namespace cross_call_worker { + /** + * @return string + */ + inline plg::string NoParamReturnString() { + return __cross_call_worker_NoParamReturnString(); + } + + using _NoParamReturnAny = plg::any (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnAny __cross_call_worker_NoParamReturnAny; +namespace cross_call_worker { + /** + * @return any + */ + inline plg::any NoParamReturnAny() { + return __cross_call_worker_NoParamReturnAny(); + } + + using _NoParamReturnArrayBool = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayBool __cross_call_worker_NoParamReturnArrayBool; +namespace cross_call_worker { + /** + * @return bool[] + */ + inline plg::vector NoParamReturnArrayBool() { + return __cross_call_worker_NoParamReturnArrayBool(); + } + + using _NoParamReturnArrayChar8 = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayChar8 __cross_call_worker_NoParamReturnArrayChar8; +namespace cross_call_worker { + /** + * @return char8[] + */ + inline plg::vector NoParamReturnArrayChar8() { + return __cross_call_worker_NoParamReturnArrayChar8(); + } + + using _NoParamReturnArrayChar16 = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayChar16 __cross_call_worker_NoParamReturnArrayChar16; +namespace cross_call_worker { + /** + * @return char16[] + */ + inline plg::vector NoParamReturnArrayChar16() { + return __cross_call_worker_NoParamReturnArrayChar16(); + } + + using _NoParamReturnArrayInt8 = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayInt8 __cross_call_worker_NoParamReturnArrayInt8; +namespace cross_call_worker { + /** + * @return int8[] + */ + inline plg::vector NoParamReturnArrayInt8() { + return __cross_call_worker_NoParamReturnArrayInt8(); + } + + using _NoParamReturnArrayInt16 = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayInt16 __cross_call_worker_NoParamReturnArrayInt16; +namespace cross_call_worker { + /** + * @return int16[] + */ + inline plg::vector NoParamReturnArrayInt16() { + return __cross_call_worker_NoParamReturnArrayInt16(); + } + + using _NoParamReturnArrayInt32 = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayInt32 __cross_call_worker_NoParamReturnArrayInt32; +namespace cross_call_worker { + /** + * @return int32[] + */ + inline plg::vector NoParamReturnArrayInt32() { + return __cross_call_worker_NoParamReturnArrayInt32(); + } + + using _NoParamReturnArrayInt64 = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayInt64 __cross_call_worker_NoParamReturnArrayInt64; +namespace cross_call_worker { + /** + * @return int64[] + */ + inline plg::vector NoParamReturnArrayInt64() { + return __cross_call_worker_NoParamReturnArrayInt64(); + } + + using _NoParamReturnArrayUInt8 = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayUInt8 __cross_call_worker_NoParamReturnArrayUInt8; +namespace cross_call_worker { + /** + * @return uint8[] + */ + inline plg::vector NoParamReturnArrayUInt8() { + return __cross_call_worker_NoParamReturnArrayUInt8(); + } + + using _NoParamReturnArrayUInt16 = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayUInt16 __cross_call_worker_NoParamReturnArrayUInt16; +namespace cross_call_worker { + /** + * @return uint16[] + */ + inline plg::vector NoParamReturnArrayUInt16() { + return __cross_call_worker_NoParamReturnArrayUInt16(); + } + + using _NoParamReturnArrayUInt32 = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayUInt32 __cross_call_worker_NoParamReturnArrayUInt32; +namespace cross_call_worker { + /** + * @return uint32[] + */ + inline plg::vector NoParamReturnArrayUInt32() { + return __cross_call_worker_NoParamReturnArrayUInt32(); + } + + using _NoParamReturnArrayUInt64 = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayUInt64 __cross_call_worker_NoParamReturnArrayUInt64; +namespace cross_call_worker { + /** + * @return uint64[] + */ + inline plg::vector NoParamReturnArrayUInt64() { + return __cross_call_worker_NoParamReturnArrayUInt64(); + } + + using _NoParamReturnArrayPointer = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayPointer __cross_call_worker_NoParamReturnArrayPointer; +namespace cross_call_worker { + /** + * @return ptr64[] + */ + inline plg::vector NoParamReturnArrayPointer() { + return __cross_call_worker_NoParamReturnArrayPointer(); + } + + using _NoParamReturnArrayFloat = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayFloat __cross_call_worker_NoParamReturnArrayFloat; +namespace cross_call_worker { + /** + * @return float[] + */ + inline plg::vector NoParamReturnArrayFloat() { + return __cross_call_worker_NoParamReturnArrayFloat(); + } + + using _NoParamReturnArrayDouble = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayDouble __cross_call_worker_NoParamReturnArrayDouble; +namespace cross_call_worker { + /** + * @return double[] + */ + inline plg::vector NoParamReturnArrayDouble() { + return __cross_call_worker_NoParamReturnArrayDouble(); + } + + using _NoParamReturnArrayString = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayString __cross_call_worker_NoParamReturnArrayString; +namespace cross_call_worker { + /** + * @return string[] + */ + inline plg::vector NoParamReturnArrayString() { + return __cross_call_worker_NoParamReturnArrayString(); + } + + using _NoParamReturnArrayAny = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayAny __cross_call_worker_NoParamReturnArrayAny; +namespace cross_call_worker { + /** + * @return any[] + */ + inline plg::vector NoParamReturnArrayAny() { + return __cross_call_worker_NoParamReturnArrayAny(); + } + + using _NoParamReturnArrayVector2 = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayVector2 __cross_call_worker_NoParamReturnArrayVector2; +namespace cross_call_worker { + /** + * @return vec2[] + */ + inline plg::vector NoParamReturnArrayVector2() { + return __cross_call_worker_NoParamReturnArrayVector2(); + } + + using _NoParamReturnArrayVector3 = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayVector3 __cross_call_worker_NoParamReturnArrayVector3; +namespace cross_call_worker { + /** + * @return vec3[] + */ + inline plg::vector NoParamReturnArrayVector3() { + return __cross_call_worker_NoParamReturnArrayVector3(); + } + + using _NoParamReturnArrayVector4 = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayVector4 __cross_call_worker_NoParamReturnArrayVector4; +namespace cross_call_worker { + /** + * @return vec4[] + */ + inline plg::vector NoParamReturnArrayVector4() { + return __cross_call_worker_NoParamReturnArrayVector4(); + } + + using _NoParamReturnArrayMatrix4x4 = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnArrayMatrix4x4 __cross_call_worker_NoParamReturnArrayMatrix4x4; +namespace cross_call_worker { + /** + * @return mat4x4[] + */ + inline plg::vector NoParamReturnArrayMatrix4x4() { + return __cross_call_worker_NoParamReturnArrayMatrix4x4(); + } + + using _NoParamReturnVector2 = plg::vec2 (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnVector2 __cross_call_worker_NoParamReturnVector2; +namespace cross_call_worker { + /** + * @return vec2 + */ + inline plg::vec2 NoParamReturnVector2() { + return __cross_call_worker_NoParamReturnVector2(); + } + + using _NoParamReturnVector3 = plg::vec3 (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnVector3 __cross_call_worker_NoParamReturnVector3; +namespace cross_call_worker { + /** + * @return vec3 + */ + inline plg::vec3 NoParamReturnVector3() { + return __cross_call_worker_NoParamReturnVector3(); + } + + using _NoParamReturnVector4 = plg::vec4 (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnVector4 __cross_call_worker_NoParamReturnVector4; +namespace cross_call_worker { + /** + * @return vec4 + */ + inline plg::vec4 NoParamReturnVector4() { + return __cross_call_worker_NoParamReturnVector4(); + } + + using _NoParamReturnMatrix4x4 = plg::mat4x4 (*)(); +} +extern "C" PLUGIN_API cross_call_worker::_NoParamReturnMatrix4x4 __cross_call_worker_NoParamReturnMatrix4x4; +namespace cross_call_worker { + /** + * @return mat4x4 + */ + inline plg::mat4x4 NoParamReturnMatrix4x4() { + return __cross_call_worker_NoParamReturnMatrix4x4(); + } + + using _Param1 = void (*)(int32_t); +} +extern "C" PLUGIN_API cross_call_worker::_Param1 __cross_call_worker_Param1; +namespace cross_call_worker { + /** + * @param a (int32) + */ + inline void Param1(int32_t a) { + return __cross_call_worker_Param1(a); + } + + using _Param2 = void (*)(int32_t, float); +} +extern "C" PLUGIN_API cross_call_worker::_Param2 __cross_call_worker_Param2; +namespace cross_call_worker { + /** + * @param a (int32) + * @param b (float) + */ + inline void Param2(int32_t a, float b) { + return __cross_call_worker_Param2(a, b); + } + + using _Param3 = void (*)(int32_t, float, double); +} +extern "C" PLUGIN_API cross_call_worker::_Param3 __cross_call_worker_Param3; +namespace cross_call_worker { + /** + * @param a (int32) + * @param b (float) + * @param c (double) + */ + inline void Param3(int32_t a, float b, double c) { + return __cross_call_worker_Param3(a, b, c); + } + + using _Param4 = void (*)(int32_t, float, double, const plg::vec4&); +} +extern "C" PLUGIN_API cross_call_worker::_Param4 __cross_call_worker_Param4; +namespace cross_call_worker { + /** + * @param a (int32) + * @param b (float) + * @param c (double) + * @param d (vec4) + */ + inline void Param4(int32_t a, float b, double c, const plg::vec4& d) { + return __cross_call_worker_Param4(a, b, c, d); + } + + using _Param5 = void (*)(int32_t, float, double, const plg::vec4&, const plg::vector&); +} +extern "C" PLUGIN_API cross_call_worker::_Param5 __cross_call_worker_Param5; +namespace cross_call_worker { + /** + * @param a (int32) + * @param b (float) + * @param c (double) + * @param d (vec4) + * @param e (int64[]) + */ + inline void Param5(int32_t a, float b, double c, const plg::vec4& d, const plg::vector& e) { + return __cross_call_worker_Param5(a, b, c, d, e); + } + + using _Param6 = void (*)(int32_t, float, double, const plg::vec4&, const plg::vector&, char); +} +extern "C" PLUGIN_API cross_call_worker::_Param6 __cross_call_worker_Param6; +namespace cross_call_worker { + /** + * @param a (int32) + * @param b (float) + * @param c (double) + * @param d (vec4) + * @param e (int64[]) + * @param f (char8) + */ + inline void Param6(int32_t a, float b, double c, const plg::vec4& d, const plg::vector& e, char f) { + return __cross_call_worker_Param6(a, b, c, d, e, f); + } + + using _Param7 = void (*)(int32_t, float, double, const plg::vec4&, const plg::vector&, char, const plg::string&); +} +extern "C" PLUGIN_API cross_call_worker::_Param7 __cross_call_worker_Param7; +namespace cross_call_worker { + /** + * @param a (int32) + * @param b (float) + * @param c (double) + * @param d (vec4) + * @param e (int64[]) + * @param f (char8) + * @param g (string) + */ + inline void Param7(int32_t a, float b, double c, const plg::vec4& d, const plg::vector& e, char f, const plg::string& g) { + return __cross_call_worker_Param7(a, b, c, d, e, f, g); + } + + using _Param8 = void (*)(int32_t, float, double, const plg::vec4&, const plg::vector&, char, const plg::string&, char16_t); +} +extern "C" PLUGIN_API cross_call_worker::_Param8 __cross_call_worker_Param8; +namespace cross_call_worker { + /** + * @param a (int32) + * @param b (float) + * @param c (double) + * @param d (vec4) + * @param e (int64[]) + * @param f (char8) + * @param g (string) + * @param h (char16) + */ + inline void Param8(int32_t a, float b, double c, const plg::vec4& d, const plg::vector& e, char f, const plg::string& g, char16_t h) { + return __cross_call_worker_Param8(a, b, c, d, e, f, g, h); + } + + using _Param9 = void (*)(int32_t, float, double, const plg::vec4&, const plg::vector&, char, const plg::string&, char16_t, int16_t); +} +extern "C" PLUGIN_API cross_call_worker::_Param9 __cross_call_worker_Param9; +namespace cross_call_worker { + /** + * @param a (int32) + * @param b (float) + * @param c (double) + * @param d (vec4) + * @param e (int64[]) + * @param f (char8) + * @param g (string) + * @param h (char16) + * @param k (int16) + */ + inline void Param9(int32_t a, float b, double c, const plg::vec4& d, const plg::vector& e, char f, const plg::string& g, char16_t h, int16_t k) { + return __cross_call_worker_Param9(a, b, c, d, e, f, g, h, k); + } + + using _Param10 = void (*)(int32_t, float, double, const plg::vec4&, const plg::vector&, char, const plg::string&, char16_t, int16_t, void*); +} +extern "C" PLUGIN_API cross_call_worker::_Param10 __cross_call_worker_Param10; +namespace cross_call_worker { + /** + * @param a (int32) + * @param b (float) + * @param c (double) + * @param d (vec4) + * @param e (int64[]) + * @param f (char8) + * @param g (string) + * @param h (char16) + * @param k (int16) + * @param l (ptr64) + */ + inline void Param10(int32_t a, float b, double c, const plg::vec4& d, const plg::vector& e, char f, const plg::string& g, char16_t h, int16_t k, void* l) { + return __cross_call_worker_Param10(a, b, c, d, e, f, g, h, k, l); + } + + using _ParamRef1 = void (*)(int32_t&); +} +extern "C" PLUGIN_API cross_call_worker::_ParamRef1 __cross_call_worker_ParamRef1; +namespace cross_call_worker { + /** + * @param a (int32&) + */ + inline void ParamRef1(int32_t& a) { + return __cross_call_worker_ParamRef1(a); + } + + using _ParamRef2 = void (*)(int32_t&, float&); +} +extern "C" PLUGIN_API cross_call_worker::_ParamRef2 __cross_call_worker_ParamRef2; +namespace cross_call_worker { + /** + * @param a (int32&) + * @param b (float&) + */ + inline void ParamRef2(int32_t& a, float& b) { + return __cross_call_worker_ParamRef2(a, b); + } + + using _ParamRef3 = void (*)(int32_t&, float&, double&); +} +extern "C" PLUGIN_API cross_call_worker::_ParamRef3 __cross_call_worker_ParamRef3; +namespace cross_call_worker { + /** + * @param a (int32&) + * @param b (float&) + * @param c (double&) + */ + inline void ParamRef3(int32_t& a, float& b, double& c) { + return __cross_call_worker_ParamRef3(a, b, c); + } + + using _ParamRef4 = void (*)(int32_t&, float&, double&, plg::vec4&); +} +extern "C" PLUGIN_API cross_call_worker::_ParamRef4 __cross_call_worker_ParamRef4; +namespace cross_call_worker { + /** + * @param a (int32&) + * @param b (float&) + * @param c (double&) + * @param d (vec4&) + */ + inline void ParamRef4(int32_t& a, float& b, double& c, plg::vec4& d) { + return __cross_call_worker_ParamRef4(a, b, c, d); + } + + using _ParamRef5 = void (*)(int32_t&, float&, double&, plg::vec4&, plg::vector&); +} +extern "C" PLUGIN_API cross_call_worker::_ParamRef5 __cross_call_worker_ParamRef5; +namespace cross_call_worker { + /** + * @param a (int32&) + * @param b (float&) + * @param c (double&) + * @param d (vec4&) + * @param e (int64[]&) + */ + inline void ParamRef5(int32_t& a, float& b, double& c, plg::vec4& d, plg::vector& e) { + return __cross_call_worker_ParamRef5(a, b, c, d, e); + } + + using _ParamRef6 = void (*)(int32_t&, float&, double&, plg::vec4&, plg::vector&, char&); +} +extern "C" PLUGIN_API cross_call_worker::_ParamRef6 __cross_call_worker_ParamRef6; +namespace cross_call_worker { + /** + * @param a (int32&) + * @param b (float&) + * @param c (double&) + * @param d (vec4&) + * @param e (int64[]&) + * @param f (char8&) + */ + inline void ParamRef6(int32_t& a, float& b, double& c, plg::vec4& d, plg::vector& e, char& f) { + return __cross_call_worker_ParamRef6(a, b, c, d, e, f); + } + + using _ParamRef7 = void (*)(int32_t&, float&, double&, plg::vec4&, plg::vector&, char&, plg::string&); +} +extern "C" PLUGIN_API cross_call_worker::_ParamRef7 __cross_call_worker_ParamRef7; +namespace cross_call_worker { + /** + * @param a (int32&) + * @param b (float&) + * @param c (double&) + * @param d (vec4&) + * @param e (int64[]&) + * @param f (char8&) + * @param g (string&) + */ + inline void ParamRef7(int32_t& a, float& b, double& c, plg::vec4& d, plg::vector& e, char& f, plg::string& g) { + return __cross_call_worker_ParamRef7(a, b, c, d, e, f, g); + } + + using _ParamRef8 = void (*)(int32_t&, float&, double&, plg::vec4&, plg::vector&, char&, plg::string&, char16_t&); +} +extern "C" PLUGIN_API cross_call_worker::_ParamRef8 __cross_call_worker_ParamRef8; +namespace cross_call_worker { + /** + * @param a (int32&) + * @param b (float&) + * @param c (double&) + * @param d (vec4&) + * @param e (int64[]&) + * @param f (char8&) + * @param g (string&) + * @param h (char16&) + */ + inline void ParamRef8(int32_t& a, float& b, double& c, plg::vec4& d, plg::vector& e, char& f, plg::string& g, char16_t& h) { + return __cross_call_worker_ParamRef8(a, b, c, d, e, f, g, h); + } + + using _ParamRef9 = void (*)(int32_t&, float&, double&, plg::vec4&, plg::vector&, char&, plg::string&, char16_t&, int16_t&); +} +extern "C" PLUGIN_API cross_call_worker::_ParamRef9 __cross_call_worker_ParamRef9; +namespace cross_call_worker { + /** + * @param a (int32&) + * @param b (float&) + * @param c (double&) + * @param d (vec4&) + * @param e (int64[]&) + * @param f (char8&) + * @param g (string&) + * @param h (char16&) + * @param k (int16&) + */ + inline void ParamRef9(int32_t& a, float& b, double& c, plg::vec4& d, plg::vector& e, char& f, plg::string& g, char16_t& h, int16_t& k) { + return __cross_call_worker_ParamRef9(a, b, c, d, e, f, g, h, k); + } + + using _ParamRef10 = void (*)(int32_t&, float&, double&, plg::vec4&, plg::vector&, char&, plg::string&, char16_t&, int16_t&, void*&); +} +extern "C" PLUGIN_API cross_call_worker::_ParamRef10 __cross_call_worker_ParamRef10; +namespace cross_call_worker { + /** + * @param a (int32&) + * @param b (float&) + * @param c (double&) + * @param d (vec4&) + * @param e (int64[]&) + * @param f (char8&) + * @param g (string&) + * @param h (char16&) + * @param k (int16&) + * @param l (ptr64&) + */ + inline void ParamRef10(int32_t& a, float& b, double& c, plg::vec4& d, plg::vector& e, char& f, plg::string& g, char16_t& h, int16_t& k, void*& l) { + return __cross_call_worker_ParamRef10(a, b, c, d, e, f, g, h, k, l); + } + + using _ParamRefVectors = void (*)(plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&); +} +extern "C" PLUGIN_API cross_call_worker::_ParamRefVectors __cross_call_worker_ParamRefVectors; +namespace cross_call_worker { + /** + * @param p1 (bool[]&) + * @param p2 (char8[]&) + * @param p3 (char16[]&) + * @param p4 (int8[]&) + * @param p5 (int16[]&) + * @param p6 (int32[]&) + * @param p7 (int64[]&) + * @param p8 (uint8[]&) + * @param p9 (uint16[]&) + * @param p10 (uint32[]&) + * @param p11 (uint64[]&) + * @param p12 (ptr64[]&) + * @param p13 (float[]&) + * @param p14 (double[]&) + * @param p15 (string[]&) + */ + inline void ParamRefVectors(plg::vector& p1, plg::vector& p2, plg::vector& p3, plg::vector& p4, plg::vector& p5, plg::vector& p6, plg::vector& p7, plg::vector& p8, plg::vector& p9, plg::vector& p10, plg::vector& p11, plg::vector& p12, plg::vector& p13, plg::vector& p14, plg::vector& p15) { + return __cross_call_worker_ParamRefVectors(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); + } + + using _ParamAllPrimitives = int64_t (*)(bool, char, char16_t, int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t, uint32_t, uint64_t, void*, float, double); +} +extern "C" PLUGIN_API cross_call_worker::_ParamAllPrimitives __cross_call_worker_ParamAllPrimitives; +namespace cross_call_worker { + /** + * @param p1 (bool) + * @param p2 (char8) + * @param p3 (char16) + * @param p4 (int8) + * @param p5 (int16) + * @param p6 (int32) + * @param p7 (int64) + * @param p8 (uint8) + * @param p9 (uint16) + * @param p10 (uint32) + * @param p11 (uint64) + * @param p12 (ptr64) + * @param p13 (float) + * @param p14 (double) + * @return int64 + */ + inline int64_t ParamAllPrimitives(bool p1, char p2, char16_t p3, int8_t p4, int16_t p5, int32_t p6, int64_t p7, uint8_t p8, uint16_t p9, uint32_t p10, uint64_t p11, void* p12, float p13, double p14) { + return __cross_call_worker_ParamAllPrimitives(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); + } + + using _ParamVariant = void (*)(const plg::any&, const plg::vector&); +} +extern "C" PLUGIN_API cross_call_worker::_ParamVariant __cross_call_worker_ParamVariant; +namespace cross_call_worker { + /** + * @param p1 (any) + * @param p2 (any[]) + */ + inline void ParamVariant(const plg::any& p1, const plg::vector& p2) { + return __cross_call_worker_ParamVariant(p1, p2); + } + + using _ParamEnum = int32_t (*)(Example, const plg::vector&); +} +extern "C" PLUGIN_API cross_call_worker::_ParamEnum __cross_call_worker_ParamEnum; +namespace cross_call_worker { + /** + * @param p1 (int32) + * @param p2 (int32[]) + * @return int32 + */ + inline int32_t ParamEnum(Example p1, const plg::vector& p2) { + return __cross_call_worker_ParamEnum(p1, p2); + } + + using _ParamEnumRef = int32_t (*)(Example&, plg::vector&); +} +extern "C" PLUGIN_API cross_call_worker::_ParamEnumRef __cross_call_worker_ParamEnumRef; +namespace cross_call_worker { + /** + * @param p1 (int32&) + * @param p2 (int32[]&) + * @return int32 + */ + inline int32_t ParamEnumRef(Example& p1, plg::vector& p2) { + return __cross_call_worker_ParamEnumRef(p1, p2); + } + + using _ParamVariantRef = void (*)(plg::any&, plg::vector&); +} +extern "C" PLUGIN_API cross_call_worker::_ParamVariantRef __cross_call_worker_ParamVariantRef; +namespace cross_call_worker { + /** + * @param p1 (any&) + * @param p2 (any[]&) + */ + inline void ParamVariantRef(plg::any& p1, plg::vector& p2) { + return __cross_call_worker_ParamVariantRef(p1, p2); + } + + using _CallFuncVoid = void (*)(FuncVoid); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncVoid __cross_call_worker_CallFuncVoid; +namespace cross_call_worker { + /** + * @param func (function) + */ + inline void CallFuncVoid(FuncVoid func) { + return __cross_call_worker_CallFuncVoid(func); + } + + using _CallFuncBool = bool (*)(FuncBool); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncBool __cross_call_worker_CallFuncBool; +namespace cross_call_worker { + /** + * @param func (function) + * @return bool + */ + inline bool CallFuncBool(FuncBool func) { + return __cross_call_worker_CallFuncBool(func); + } + + using _CallFuncChar8 = char (*)(FuncChar8); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncChar8 __cross_call_worker_CallFuncChar8; +namespace cross_call_worker { + /** + * @param func (function) + * @return char8 + */ + inline char CallFuncChar8(FuncChar8 func) { + return __cross_call_worker_CallFuncChar8(func); + } + + using _CallFuncChar16 = char16_t (*)(FuncChar16); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncChar16 __cross_call_worker_CallFuncChar16; +namespace cross_call_worker { + /** + * @param func (function) + * @return char16 + */ + inline char16_t CallFuncChar16(FuncChar16 func) { + return __cross_call_worker_CallFuncChar16(func); + } + + using _CallFuncInt8 = int8_t (*)(FuncInt8); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncInt8 __cross_call_worker_CallFuncInt8; +namespace cross_call_worker { + /** + * @param func (function) + * @return int8 + */ + inline int8_t CallFuncInt8(FuncInt8 func) { + return __cross_call_worker_CallFuncInt8(func); + } + + using _CallFuncInt16 = int16_t (*)(FuncInt16); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncInt16 __cross_call_worker_CallFuncInt16; +namespace cross_call_worker { + /** + * @param func (function) + * @return int16 + */ + inline int16_t CallFuncInt16(FuncInt16 func) { + return __cross_call_worker_CallFuncInt16(func); + } + + using _CallFuncInt32 = int32_t (*)(FuncInt32); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncInt32 __cross_call_worker_CallFuncInt32; +namespace cross_call_worker { + /** + * @param func (function) + * @return int32 + */ + inline int32_t CallFuncInt32(FuncInt32 func) { + return __cross_call_worker_CallFuncInt32(func); + } + + using _CallFuncInt64 = int64_t (*)(FuncInt64); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncInt64 __cross_call_worker_CallFuncInt64; +namespace cross_call_worker { + /** + * @param func (function) + * @return int64 + */ + inline int64_t CallFuncInt64(FuncInt64 func) { + return __cross_call_worker_CallFuncInt64(func); + } + + using _CallFuncUInt8 = uint8_t (*)(FuncUInt8); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncUInt8 __cross_call_worker_CallFuncUInt8; +namespace cross_call_worker { + /** + * @param func (function) + * @return uint8 + */ + inline uint8_t CallFuncUInt8(FuncUInt8 func) { + return __cross_call_worker_CallFuncUInt8(func); + } + + using _CallFuncUInt16 = uint16_t (*)(FuncUInt16); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncUInt16 __cross_call_worker_CallFuncUInt16; +namespace cross_call_worker { + /** + * @param func (function) + * @return uint16 + */ + inline uint16_t CallFuncUInt16(FuncUInt16 func) { + return __cross_call_worker_CallFuncUInt16(func); + } + + using _CallFuncUInt32 = uint32_t (*)(FuncUInt32); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncUInt32 __cross_call_worker_CallFuncUInt32; +namespace cross_call_worker { + /** + * @param func (function) + * @return uint32 + */ + inline uint32_t CallFuncUInt32(FuncUInt32 func) { + return __cross_call_worker_CallFuncUInt32(func); + } + + using _CallFuncUInt64 = uint64_t (*)(FuncUInt64); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncUInt64 __cross_call_worker_CallFuncUInt64; +namespace cross_call_worker { + /** + * @param func (function) + * @return uint64 + */ + inline uint64_t CallFuncUInt64(FuncUInt64 func) { + return __cross_call_worker_CallFuncUInt64(func); + } + + using _CallFuncPtr = void* (*)(FuncPtr); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncPtr __cross_call_worker_CallFuncPtr; +namespace cross_call_worker { + /** + * @param func (function) + * @return ptr64 + */ + inline void* CallFuncPtr(FuncPtr func) { + return __cross_call_worker_CallFuncPtr(func); + } + + using _CallFuncFloat = float (*)(FuncFloat); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncFloat __cross_call_worker_CallFuncFloat; +namespace cross_call_worker { + /** + * @param func (function) + * @return float + */ + inline float CallFuncFloat(FuncFloat func) { + return __cross_call_worker_CallFuncFloat(func); + } + + using _CallFuncDouble = double (*)(FuncDouble); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncDouble __cross_call_worker_CallFuncDouble; +namespace cross_call_worker { + /** + * @param func (function) + * @return double + */ + inline double CallFuncDouble(FuncDouble func) { + return __cross_call_worker_CallFuncDouble(func); + } + + using _CallFuncString = plg::string (*)(FuncString); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncString __cross_call_worker_CallFuncString; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFuncString(FuncString func) { + return __cross_call_worker_CallFuncString(func); + } + + using _CallFuncAny = plg::any (*)(FuncAny); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncAny __cross_call_worker_CallFuncAny; +namespace cross_call_worker { + /** + * @param func (function) + * @return any + */ + inline plg::any CallFuncAny(FuncAny func) { + return __cross_call_worker_CallFuncAny(func); + } + + using _CallFuncFunction = void* (*)(FuncFunction); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncFunction __cross_call_worker_CallFuncFunction; +namespace cross_call_worker { + /** + * @param func (function) + * @return ptr64 + */ + inline void* CallFuncFunction(FuncFunction func) { + return __cross_call_worker_CallFuncFunction(func); + } + + using _CallFuncBoolVector = plg::vector (*)(FuncBoolVector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncBoolVector __cross_call_worker_CallFuncBoolVector; +namespace cross_call_worker { + /** + * @param func (function) + * @return bool[] + */ + inline plg::vector CallFuncBoolVector(FuncBoolVector func) { + return __cross_call_worker_CallFuncBoolVector(func); + } + + using _CallFuncChar8Vector = plg::vector (*)(FuncChar8Vector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncChar8Vector __cross_call_worker_CallFuncChar8Vector; +namespace cross_call_worker { + /** + * @param func (function) + * @return char8[] + */ + inline plg::vector CallFuncChar8Vector(FuncChar8Vector func) { + return __cross_call_worker_CallFuncChar8Vector(func); + } + + using _CallFuncChar16Vector = plg::vector (*)(FuncChar16Vector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncChar16Vector __cross_call_worker_CallFuncChar16Vector; +namespace cross_call_worker { + /** + * @param func (function) + * @return char16[] + */ + inline plg::vector CallFuncChar16Vector(FuncChar16Vector func) { + return __cross_call_worker_CallFuncChar16Vector(func); + } + + using _CallFuncInt8Vector = plg::vector (*)(FuncInt8Vector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncInt8Vector __cross_call_worker_CallFuncInt8Vector; +namespace cross_call_worker { + /** + * @param func (function) + * @return int8[] + */ + inline plg::vector CallFuncInt8Vector(FuncInt8Vector func) { + return __cross_call_worker_CallFuncInt8Vector(func); + } + + using _CallFuncInt16Vector = plg::vector (*)(FuncInt16Vector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncInt16Vector __cross_call_worker_CallFuncInt16Vector; +namespace cross_call_worker { + /** + * @param func (function) + * @return int16[] + */ + inline plg::vector CallFuncInt16Vector(FuncInt16Vector func) { + return __cross_call_worker_CallFuncInt16Vector(func); + } + + using _CallFuncInt32Vector = plg::vector (*)(FuncInt32Vector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncInt32Vector __cross_call_worker_CallFuncInt32Vector; +namespace cross_call_worker { + /** + * @param func (function) + * @return int32[] + */ + inline plg::vector CallFuncInt32Vector(FuncInt32Vector func) { + return __cross_call_worker_CallFuncInt32Vector(func); + } + + using _CallFuncInt64Vector = plg::vector (*)(FuncInt64Vector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncInt64Vector __cross_call_worker_CallFuncInt64Vector; +namespace cross_call_worker { + /** + * @param func (function) + * @return int64[] + */ + inline plg::vector CallFuncInt64Vector(FuncInt64Vector func) { + return __cross_call_worker_CallFuncInt64Vector(func); + } + + using _CallFuncUInt8Vector = plg::vector (*)(FuncUInt8Vector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncUInt8Vector __cross_call_worker_CallFuncUInt8Vector; +namespace cross_call_worker { + /** + * @param func (function) + * @return uint8[] + */ + inline plg::vector CallFuncUInt8Vector(FuncUInt8Vector func) { + return __cross_call_worker_CallFuncUInt8Vector(func); + } + + using _CallFuncUInt16Vector = plg::vector (*)(FuncUInt16Vector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncUInt16Vector __cross_call_worker_CallFuncUInt16Vector; +namespace cross_call_worker { + /** + * @param func (function) + * @return uint16[] + */ + inline plg::vector CallFuncUInt16Vector(FuncUInt16Vector func) { + return __cross_call_worker_CallFuncUInt16Vector(func); + } + + using _CallFuncUInt32Vector = plg::vector (*)(FuncUInt32Vector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncUInt32Vector __cross_call_worker_CallFuncUInt32Vector; +namespace cross_call_worker { + /** + * @param func (function) + * @return uint32[] + */ + inline plg::vector CallFuncUInt32Vector(FuncUInt32Vector func) { + return __cross_call_worker_CallFuncUInt32Vector(func); + } + + using _CallFuncUInt64Vector = plg::vector (*)(FuncUInt64Vector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncUInt64Vector __cross_call_worker_CallFuncUInt64Vector; +namespace cross_call_worker { + /** + * @param func (function) + * @return uint64[] + */ + inline plg::vector CallFuncUInt64Vector(FuncUInt64Vector func) { + return __cross_call_worker_CallFuncUInt64Vector(func); + } + + using _CallFuncPtrVector = plg::vector (*)(FuncPtrVector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncPtrVector __cross_call_worker_CallFuncPtrVector; +namespace cross_call_worker { + /** + * @param func (function) + * @return ptr64[] + */ + inline plg::vector CallFuncPtrVector(FuncPtrVector func) { + return __cross_call_worker_CallFuncPtrVector(func); + } + + using _CallFuncFloatVector = plg::vector (*)(FuncFloatVector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncFloatVector __cross_call_worker_CallFuncFloatVector; +namespace cross_call_worker { + /** + * @param func (function) + * @return float[] + */ + inline plg::vector CallFuncFloatVector(FuncFloatVector func) { + return __cross_call_worker_CallFuncFloatVector(func); + } + + using _CallFuncDoubleVector = plg::vector (*)(FuncDoubleVector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncDoubleVector __cross_call_worker_CallFuncDoubleVector; +namespace cross_call_worker { + /** + * @param func (function) + * @return double[] + */ + inline plg::vector CallFuncDoubleVector(FuncDoubleVector func) { + return __cross_call_worker_CallFuncDoubleVector(func); + } + + using _CallFuncStringVector = plg::vector (*)(FuncStringVector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncStringVector __cross_call_worker_CallFuncStringVector; +namespace cross_call_worker { + /** + * @param func (function) + * @return string[] + */ + inline plg::vector CallFuncStringVector(FuncStringVector func) { + return __cross_call_worker_CallFuncStringVector(func); + } + + using _CallFuncAnyVector = plg::vector (*)(FuncAnyVector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncAnyVector __cross_call_worker_CallFuncAnyVector; +namespace cross_call_worker { + /** + * @param func (function) + * @return any[] + */ + inline plg::vector CallFuncAnyVector(FuncAnyVector func) { + return __cross_call_worker_CallFuncAnyVector(func); + } + + using _CallFuncVec2Vector = plg::vector (*)(FuncVec2Vector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncVec2Vector __cross_call_worker_CallFuncVec2Vector; +namespace cross_call_worker { + /** + * @param func (function) + * @return vec2[] + */ + inline plg::vector CallFuncVec2Vector(FuncVec2Vector func) { + return __cross_call_worker_CallFuncVec2Vector(func); + } + + using _CallFuncVec3Vector = plg::vector (*)(FuncVec3Vector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncVec3Vector __cross_call_worker_CallFuncVec3Vector; +namespace cross_call_worker { + /** + * @param func (function) + * @return vec3[] + */ + inline plg::vector CallFuncVec3Vector(FuncVec3Vector func) { + return __cross_call_worker_CallFuncVec3Vector(func); + } + + using _CallFuncVec4Vector = plg::vector (*)(FuncVec4Vector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncVec4Vector __cross_call_worker_CallFuncVec4Vector; +namespace cross_call_worker { + /** + * @param func (function) + * @return vec4[] + */ + inline plg::vector CallFuncVec4Vector(FuncVec4Vector func) { + return __cross_call_worker_CallFuncVec4Vector(func); + } + + using _CallFuncMat4x4Vector = plg::vector (*)(FuncMat4x4Vector); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncMat4x4Vector __cross_call_worker_CallFuncMat4x4Vector; +namespace cross_call_worker { + /** + * @param func (function) + * @return mat4x4[] + */ + inline plg::vector CallFuncMat4x4Vector(FuncMat4x4Vector func) { + return __cross_call_worker_CallFuncMat4x4Vector(func); + } + + using _CallFuncVec2 = plg::vec2 (*)(FuncVec2); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncVec2 __cross_call_worker_CallFuncVec2; +namespace cross_call_worker { + /** + * @param func (function) + * @return vec2 + */ + inline plg::vec2 CallFuncVec2(FuncVec2 func) { + return __cross_call_worker_CallFuncVec2(func); + } + + using _CallFuncVec3 = plg::vec3 (*)(FuncVec3); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncVec3 __cross_call_worker_CallFuncVec3; +namespace cross_call_worker { + /** + * @param func (function) + * @return vec3 + */ + inline plg::vec3 CallFuncVec3(FuncVec3 func) { + return __cross_call_worker_CallFuncVec3(func); + } + + using _CallFuncVec4 = plg::vec4 (*)(FuncVec4); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncVec4 __cross_call_worker_CallFuncVec4; +namespace cross_call_worker { + /** + * @param func (function) + * @return vec4 + */ + inline plg::vec4 CallFuncVec4(FuncVec4 func) { + return __cross_call_worker_CallFuncVec4(func); + } + + using _CallFuncMat4x4 = plg::mat4x4 (*)(FuncMat4x4); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncMat4x4 __cross_call_worker_CallFuncMat4x4; +namespace cross_call_worker { + /** + * @param func (function) + * @return mat4x4 + */ + inline plg::mat4x4 CallFuncMat4x4(FuncMat4x4 func) { + return __cross_call_worker_CallFuncMat4x4(func); + } + + using _CallFunc1 = int32_t (*)(Func1); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc1 __cross_call_worker_CallFunc1; +namespace cross_call_worker { + /** + * @param func (function) + * @return int32 + */ + inline int32_t CallFunc1(Func1 func) { + return __cross_call_worker_CallFunc1(func); + } + + using _CallFunc2 = char (*)(Func2); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc2 __cross_call_worker_CallFunc2; +namespace cross_call_worker { + /** + * @param func (function) + * @return char8 + */ + inline char CallFunc2(Func2 func) { + return __cross_call_worker_CallFunc2(func); + } + + using _CallFunc3 = void (*)(Func3); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc3 __cross_call_worker_CallFunc3; +namespace cross_call_worker { + /** + * @param func (function) + */ + inline void CallFunc3(Func3 func) { + return __cross_call_worker_CallFunc3(func); + } + + using _CallFunc4 = plg::vec4 (*)(Func4); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc4 __cross_call_worker_CallFunc4; +namespace cross_call_worker { + /** + * @param func (function) + * @return vec4 + */ + inline plg::vec4 CallFunc4(Func4 func) { + return __cross_call_worker_CallFunc4(func); + } + + using _CallFunc5 = bool (*)(Func5); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc5 __cross_call_worker_CallFunc5; +namespace cross_call_worker { + /** + * @param func (function) + * @return bool + */ + inline bool CallFunc5(Func5 func) { + return __cross_call_worker_CallFunc5(func); + } + + using _CallFunc6 = int64_t (*)(Func6); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc6 __cross_call_worker_CallFunc6; +namespace cross_call_worker { + /** + * @param func (function) + * @return int64 + */ + inline int64_t CallFunc6(Func6 func) { + return __cross_call_worker_CallFunc6(func); + } + + using _CallFunc7 = double (*)(Func7); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc7 __cross_call_worker_CallFunc7; +namespace cross_call_worker { + /** + * @param func (function) + * @return double + */ + inline double CallFunc7(Func7 func) { + return __cross_call_worker_CallFunc7(func); + } + + using _CallFunc8 = plg::mat4x4 (*)(Func8); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc8 __cross_call_worker_CallFunc8; +namespace cross_call_worker { + /** + * @param func (function) + * @return mat4x4 + */ + inline plg::mat4x4 CallFunc8(Func8 func) { + return __cross_call_worker_CallFunc8(func); + } + + using _CallFunc9 = void (*)(Func9); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc9 __cross_call_worker_CallFunc9; +namespace cross_call_worker { + /** + * @param func (function) + */ + inline void CallFunc9(Func9 func) { + return __cross_call_worker_CallFunc9(func); + } + + using _CallFunc10 = uint32_t (*)(Func10); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc10 __cross_call_worker_CallFunc10; +namespace cross_call_worker { + /** + * @param func (function) + * @return uint32 + */ + inline uint32_t CallFunc10(Func10 func) { + return __cross_call_worker_CallFunc10(func); + } + + using _CallFunc11 = void* (*)(Func11); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc11 __cross_call_worker_CallFunc11; +namespace cross_call_worker { + /** + * @param func (function) + * @return ptr64 + */ + inline void* CallFunc11(Func11 func) { + return __cross_call_worker_CallFunc11(func); + } + + using _CallFunc12 = bool (*)(Func12); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc12 __cross_call_worker_CallFunc12; +namespace cross_call_worker { + /** + * @param func (function) + * @return bool + */ + inline bool CallFunc12(Func12 func) { + return __cross_call_worker_CallFunc12(func); + } + + using _CallFunc13 = plg::string (*)(Func13); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc13 __cross_call_worker_CallFunc13; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc13(Func13 func) { + return __cross_call_worker_CallFunc13(func); + } + + using _CallFunc14 = plg::vector (*)(Func14); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc14 __cross_call_worker_CallFunc14; +namespace cross_call_worker { + /** + * @param func (function) + * @return string[] + */ + inline plg::vector CallFunc14(Func14 func) { + return __cross_call_worker_CallFunc14(func); + } + + using _CallFunc15 = int16_t (*)(Func15); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc15 __cross_call_worker_CallFunc15; +namespace cross_call_worker { + /** + * @param func (function) + * @return int16 + */ + inline int16_t CallFunc15(Func15 func) { + return __cross_call_worker_CallFunc15(func); + } + + using _CallFunc16 = void* (*)(Func16); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc16 __cross_call_worker_CallFunc16; +namespace cross_call_worker { + /** + * @param func (function) + * @return ptr64 + */ + inline void* CallFunc16(Func16 func) { + return __cross_call_worker_CallFunc16(func); + } + + using _CallFunc17 = plg::string (*)(Func17); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc17 __cross_call_worker_CallFunc17; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc17(Func17 func) { + return __cross_call_worker_CallFunc17(func); + } + + using _CallFunc18 = plg::string (*)(Func18); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc18 __cross_call_worker_CallFunc18; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc18(Func18 func) { + return __cross_call_worker_CallFunc18(func); + } + + using _CallFunc19 = plg::string (*)(Func19); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc19 __cross_call_worker_CallFunc19; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc19(Func19 func) { + return __cross_call_worker_CallFunc19(func); + } + + using _CallFunc20 = plg::string (*)(Func20); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc20 __cross_call_worker_CallFunc20; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc20(Func20 func) { + return __cross_call_worker_CallFunc20(func); + } + + using _CallFunc21 = plg::string (*)(Func21); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc21 __cross_call_worker_CallFunc21; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc21(Func21 func) { + return __cross_call_worker_CallFunc21(func); + } + + using _CallFunc22 = plg::string (*)(Func22); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc22 __cross_call_worker_CallFunc22; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc22(Func22 func) { + return __cross_call_worker_CallFunc22(func); + } + + using _CallFunc23 = plg::string (*)(Func23); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc23 __cross_call_worker_CallFunc23; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc23(Func23 func) { + return __cross_call_worker_CallFunc23(func); + } + + using _CallFunc24 = plg::string (*)(Func24); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc24 __cross_call_worker_CallFunc24; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc24(Func24 func) { + return __cross_call_worker_CallFunc24(func); + } + + using _CallFunc25 = plg::string (*)(Func25); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc25 __cross_call_worker_CallFunc25; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc25(Func25 func) { + return __cross_call_worker_CallFunc25(func); + } + + using _CallFunc26 = plg::string (*)(Func26); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc26 __cross_call_worker_CallFunc26; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc26(Func26 func) { + return __cross_call_worker_CallFunc26(func); + } + + using _CallFunc27 = plg::string (*)(Func27); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc27 __cross_call_worker_CallFunc27; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc27(Func27 func) { + return __cross_call_worker_CallFunc27(func); + } + + using _CallFunc28 = plg::string (*)(Func28); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc28 __cross_call_worker_CallFunc28; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc28(Func28 func) { + return __cross_call_worker_CallFunc28(func); + } + + using _CallFunc29 = plg::string (*)(Func29); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc29 __cross_call_worker_CallFunc29; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc29(Func29 func) { + return __cross_call_worker_CallFunc29(func); + } + + using _CallFunc30 = plg::string (*)(Func30); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc30 __cross_call_worker_CallFunc30; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc30(Func30 func) { + return __cross_call_worker_CallFunc30(func); + } + + using _CallFunc31 = plg::string (*)(Func31); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc31 __cross_call_worker_CallFunc31; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc31(Func31 func) { + return __cross_call_worker_CallFunc31(func); + } + + using _CallFunc32 = plg::string (*)(Func32); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc32 __cross_call_worker_CallFunc32; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc32(Func32 func) { + return __cross_call_worker_CallFunc32(func); + } + + using _CallFunc33 = plg::string (*)(Func33); +} +extern "C" PLUGIN_API cross_call_worker::_CallFunc33 __cross_call_worker_CallFunc33; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc33(Func33 func) { + return __cross_call_worker_CallFunc33(func); + } + + using _CallFuncEnum = plg::string (*)(FuncEnum); +} +extern "C" PLUGIN_API cross_call_worker::_CallFuncEnum __cross_call_worker_CallFuncEnum; +namespace cross_call_worker { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFuncEnum(FuncEnum func) { + return __cross_call_worker_CallFuncEnum(func); + } + + using _ReverseCall = void (*)(const plg::string&); +} +extern "C" PLUGIN_API cross_call_worker::_ReverseCall __cross_call_worker_ReverseCall; +namespace cross_call_worker { + /** + * @param test (string) + */ + inline void ReverseCall(const plg::string& test) { + return __cross_call_worker_ReverseCall(test); + } + +} // namespace cross_call_worker diff --git a/test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker/delegates.hpp b/test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker/delegates.hpp new file mode 100644 index 0000000..c71a9e0 --- /dev/null +++ b/test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker/delegates.hpp @@ -0,0 +1,165 @@ +#pragma once + +#include "enums.hpp" +#include +#include + +// Generated from cross_call_worker.pplugin + +namespace cross_call_worker { + + using NoParamReturnFunctionFunc = void (*)(); + + using FuncVoid = void (*)(); + + using FuncBool = bool (*)(); + + using FuncChar8 = char (*)(); + + using FuncChar16 = char16_t (*)(); + + using FuncInt8 = int8_t (*)(); + + using FuncInt16 = int16_t (*)(); + + using FuncInt32 = int32_t (*)(); + + using FuncInt64 = int64_t (*)(); + + using FuncUInt8 = uint8_t (*)(); + + using FuncUInt16 = uint16_t (*)(); + + using FuncUInt32 = uint32_t (*)(); + + using FuncUInt64 = uint64_t (*)(); + + using FuncPtr = void* (*)(); + + using FuncFloat = float (*)(); + + using FuncDouble = double (*)(); + + using FuncString = plg::string (*)(); + + using FuncAny = plg::any (*)(); + + using FuncFunction = void* (*)(); + + using FuncBoolVector = plg::vector (*)(); + + using FuncChar8Vector = plg::vector (*)(); + + using FuncChar16Vector = plg::vector (*)(); + + using FuncInt8Vector = plg::vector (*)(); + + using FuncInt16Vector = plg::vector (*)(); + + using FuncInt32Vector = plg::vector (*)(); + + using FuncInt64Vector = plg::vector (*)(); + + using FuncUInt8Vector = plg::vector (*)(); + + using FuncUInt16Vector = plg::vector (*)(); + + using FuncUInt32Vector = plg::vector (*)(); + + using FuncUInt64Vector = plg::vector (*)(); + + using FuncPtrVector = plg::vector (*)(); + + using FuncFloatVector = plg::vector (*)(); + + using FuncDoubleVector = plg::vector (*)(); + + using FuncStringVector = plg::vector (*)(); + + using FuncAnyVector = plg::vector (*)(); + + using FuncVec2Vector = plg::vector (*)(); + + using FuncVec3Vector = plg::vector (*)(); + + using FuncVec4Vector = plg::vector (*)(); + + using FuncMat4x4Vector = plg::vector (*)(); + + using FuncVec2 = plg::vec2 (*)(); + + using FuncVec3 = plg::vec3 (*)(); + + using FuncVec4 = plg::vec4 (*)(); + + using FuncMat4x4 = plg::mat4x4 (*)(); + + using Func1 = int32_t (*)(const plg::vec3&); + + using Func2 = char (*)(float, int64_t); + + using Func3 = void (*)(void*, const plg::vec4&, const plg::string&); + + using Func4 = plg::vec4 (*)(bool, int32_t, char16_t, const plg::mat4x4&); + + using Func5 = bool (*)(int8_t, const plg::vec2&, void*, double, const plg::vector&); + + using Func6 = int64_t (*)(const plg::string&, float, const plg::vector&, int16_t, const plg::vector&, void*); + + using Func7 = double (*)(const plg::vector&, uint16_t, char16_t, const plg::vector&, const plg::vec4&, bool, uint64_t); + + using Func8 = plg::mat4x4 (*)(const plg::vec3&, const plg::vector&, int16_t, bool, const plg::vec4&, const plg::vector&, char16_t, int32_t); + + using Func9 = void (*)(float, const plg::vec2&, const plg::vector&, uint64_t, bool, const plg::string&, const plg::vec4&, int16_t, void*); + + using Func10 = uint32_t (*)(const plg::vec4&, const plg::mat4x4&, const plg::vector&, uint64_t, const plg::vector&, int32_t, bool, const plg::vec2&, int64_t, double); + + using Func11 = void* (*)(const plg::vector&, char16_t, uint8_t, double, const plg::vec3&, const plg::vector&, int64_t, uint16_t, float, const plg::vec2&, uint32_t); + + using Func12 = bool (*)(void*, const plg::vector&, uint32_t, double, bool, int32_t, int8_t, uint64_t, float, const plg::vector&, int64_t, char); + + using Func13 = plg::string (*)(int64_t, const plg::vector&, uint16_t, float, const plg::vector&, const plg::vec4&, const plg::string&, int32_t, const plg::vec3&, void*, const plg::vec2&, const plg::vector&, int16_t); + + using Func14 = plg::vector (*)(const plg::vector&, const plg::vector&, const plg::mat4x4&, bool, char16_t, int32_t, const plg::vector&, uint16_t, const plg::vector&, int8_t, const plg::vec3&, const plg::vec4&, double, void*); + + using Func15 = int16_t (*)(const plg::vector&, const plg::mat4x4&, const plg::vec4&, void*, uint64_t, const plg::vector&, bool, float, const plg::vector&, uint8_t, int32_t, const plg::vec2&, uint16_t, double, const plg::vector&); + + using Func16 = void* (*)(const plg::vector&, int16_t, const plg::vector&, const plg::vec4&, const plg::mat4x4&, const plg::vec2&, const plg::vector&, const plg::vector&, const plg::string&, int64_t, const plg::vector&, const plg::vec3&, float, double, int8_t, uint16_t); + + using Func17 = void (*)(int32_t&); + + using Func18 = plg::vec2 (*)(int8_t&, int16_t&); + + using Func19 = void (*)(uint32_t&, plg::vec3&, plg::vector&); + + using Func20 = int32_t (*)(char16_t&, plg::vec4&, plg::vector&, char&); + + using Func21 = float (*)(plg::mat4x4&, plg::vector&, plg::vec2&, bool&, double&); + + using Func22 = uint64_t (*)(void*&, uint32_t&, plg::vector&, int16_t&, plg::string&, plg::vec4&); + + using Func23 = void (*)(uint64_t&, plg::vec2&, plg::vector&, char16_t&, float&, int8_t&, plg::vector&); + + using Func24 = plg::mat4x4 (*)(plg::vector&, int64_t&, plg::vector&, plg::vec4&, uint64_t&, plg::vector&, double&, plg::vector&); + + using Func25 = double (*)(int32_t&, plg::vector&, bool&, uint8_t&, plg::string&, plg::vec3&, int64_t&, plg::vec4&, uint16_t&); + + using Func26 = char (*)(char16_t&, plg::vec2&, plg::mat4x4&, plg::vector&, int16_t&, uint64_t&, uint32_t&, plg::vector&, void*&, bool&); + + using Func27 = uint8_t (*)(float&, plg::vec3&, void*&, plg::vec2&, plg::vector&, plg::mat4x4&, bool&, plg::vec4&, int8_t&, int32_t&, plg::vector&); + + using Func28 = plg::string (*)(void*&, uint16_t&, plg::vector&, plg::mat4x4&, float&, plg::vec4&, plg::string&, plg::vector&, int64_t&, bool&, plg::vec3&, plg::vector&); + + using Func29 = plg::vector (*)(plg::vec4&, int32_t&, plg::vector&, double&, bool&, int8_t&, plg::vector&, float&, plg::string&, plg::mat4x4&, uint64_t&, plg::vec3&, plg::vector&); + + using Func30 = int32_t (*)(void*&, plg::vec4&, int64_t&, plg::vector&, bool&, plg::string&, plg::vec3&, plg::vector&, float&, plg::vec2&, plg::mat4x4&, int8_t&, plg::vector&, double&); + + using Func31 = plg::vec3 (*)(char&, uint32_t&, plg::vector&, plg::vec4&, plg::string&, bool&, int64_t&, plg::vec2&, int8_t&, uint16_t&, plg::vector&, plg::mat4x4&, plg::vec3&, float&, plg::vector&); + + using Func32 = double (*)(int32_t&, uint16_t&, plg::vector&, plg::vec4&, void*&, plg::vector&, plg::mat4x4&, uint64_t&, plg::string&, int64_t&, plg::vec2&, plg::vector&, bool&, plg::vec3&, uint8_t&, plg::vector&); + + using Func33 = void (*)(plg::any&); + + using FuncEnum = plg::vector (*)(Example, plg::vector&); + +} // namespace cross_call_worker diff --git a/test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker/enums.hpp b/test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker/enums.hpp new file mode 100644 index 0000000..bfe975a --- /dev/null +++ b/test/cross_call_master/external/plugify/include/cross_call_worker/cross_call_worker/enums.hpp @@ -0,0 +1,19 @@ +#pragma once + +#include +// Generated from cross_call_worker.pplugin + +namespace cross_call_worker { + + enum class Example : int32_t { + First = 1, + Second = 2, + Third = 3, + Forth = 4 + }; + + + /// Ownership type for RAII wrappers + enum class Ownership : bool { Borrowed, Owned }; + +} // namespace cross_call_worker diff --git a/test/cross_call_master/external/plugify/include/plg/plugin.hpp b/test/cross_call_master/external/plugify/include/plg/plugin.hpp index 550b623..9308ea9 100644 --- a/test/cross_call_master/external/plugify/include/plg/plugin.hpp +++ b/test/cross_call_master/external/plugify/include/plg/plugin.hpp @@ -7,6 +7,7 @@ #include #include #include +#include #include #include "plg/any.hpp" @@ -14,8 +15,6 @@ #include "plg/api.hpp" namespace plg { - using GetMethodPtrFn = void* (*)(std::string_view); - using GetMethodPtr2Fn = void (*)(std::string_view, void**); using GetBaseDirFn = plg::string (*)(); using GetExtensionsDirFn = plg::string (*)(); using GetConfigsDirFn = plg::string (*)(); @@ -24,8 +23,6 @@ namespace plg { using GetCacheDirFn = plg::string (*)(); using IsExtensionLoadedFn = bool (*)(std::string_view, std::optional>); - extern GetMethodPtrFn GetMethodPtr; - extern GetMethodPtr2Fn GetMethodPtr2; extern GetBaseDirFn GetBaseDir; extern GetExtensionsDirFn GetExtensionsDir; extern GetConfigsDirFn GetConfigsDir; @@ -90,8 +87,6 @@ namespace plg { #define EXPOSE_PLUGIN(plugin_api, plugin_class, plugin_addr) \ namespace plg { \ - GetMethodPtrFn GetMethodPtr{nullptr}; \ - GetMethodPtr2Fn GetMethodPtr2{nullptr}; \ GetBaseDirFn GetBaseDir{nullptr}; \ GetExtensionsDirFn GetExtensionsDir{nullptr}; \ GetConfigsDirFn GetConfigsDir{nullptr}; \ @@ -111,13 +106,12 @@ namespace plg { GetLocationFn GetLocation{nullptr}; \ GetDependenciesFn GetDependencies{nullptr}; \ } \ - extern "C" plugin_api int Plugify_Init(void** api, int version, void* handle) { \ + extern "C" plugin_api int Plugify_Init(void** data, size_t len, int version, void* handle) { \ if (version < kApiVersion) { \ return kApiVersion; \ } \ + std::span api(data, len); \ size_t i = 0; \ - GetMethodPtr = reinterpret_cast(api[i++]); \ - GetMethodPtr2 = reinterpret_cast(api[i++]); \ GetBaseDir = reinterpret_cast(api[i++]); \ GetExtensionsDir = reinterpret_cast(api[i++]); \ GetConfigsDir = reinterpret_cast(api[i++]); \ @@ -180,16 +174,17 @@ namespace plg { namespace plg { namespace raw { + template struct vector { - uint8_t pad[sizeof(plg::vector)]{}; + alignas(plg::vector) unsigned char pad[sizeof(plg::vector)]{}; }; struct string { - uint8_t pad[sizeof(plg::string)]{}; + alignas(plg::string) unsigned char pad[sizeof(plg::string)]{}; }; struct variant { - uint8_t pad[sizeof(plg::any)]{}; + alignas(plg::any) unsigned char pad[sizeof(plg::any)]{}; }; } // namespace raw diff --git a/test/cross_call_master/external/plugify/include/pps/cross_call_worker.hpp b/test/cross_call_master/external/plugify/include/pps/cross_call_worker.hpp deleted file mode 100644 index 0af3cec..0000000 --- a/test/cross_call_master/external/plugify/include/pps/cross_call_worker.hpp +++ /dev/null @@ -1,3161 +0,0 @@ -#pragma once - -#include -#include -#include - -// Generated from cross_call_worker.pplugin by https://github.com/untrustedmodders/plugify-module-cpp/blob/main/generator/generator.py - -namespace cross_call_worker { - enum class Example : int32_t { - First = 1, - Second = 2, - Third = 3, - Forth = 4, - }; - - using NoParamReturnFunctionFunc = void (*)(); - using FuncVoid = void (*)(); - using FuncBool = bool (*)(); - using FuncChar8 = char (*)(); - using FuncChar16 = char16_t (*)(); - using FuncInt8 = int8_t (*)(); - using FuncInt16 = int16_t (*)(); - using FuncInt32 = int32_t (*)(); - using FuncInt64 = int64_t (*)(); - using FuncUInt8 = uint8_t (*)(); - using FuncUInt16 = uint16_t (*)(); - using FuncUInt32 = uint32_t (*)(); - using FuncUInt64 = uint64_t (*)(); - using FuncPtr = void* (*)(); - using FuncFloat = float (*)(); - using FuncDouble = double (*)(); - using FuncString = plg::string (*)(); - using FuncAny = plg::any (*)(); - using FuncFunction = void* (*)(); - using FuncBoolVector = plg::vector (*)(); - using FuncChar8Vector = plg::vector (*)(); - using FuncChar16Vector = plg::vector (*)(); - using FuncInt8Vector = plg::vector (*)(); - using FuncInt16Vector = plg::vector (*)(); - using FuncInt32Vector = plg::vector (*)(); - using FuncInt64Vector = plg::vector (*)(); - using FuncUInt8Vector = plg::vector (*)(); - using FuncUInt16Vector = plg::vector (*)(); - using FuncUInt32Vector = plg::vector (*)(); - using FuncUInt64Vector = plg::vector (*)(); - using FuncPtrVector = plg::vector (*)(); - using FuncFloatVector = plg::vector (*)(); - using FuncDoubleVector = plg::vector (*)(); - using FuncStringVector = plg::vector (*)(); - using FuncAnyVector = plg::vector (*)(); - using FuncVec2Vector = plg::vector (*)(); - using FuncVec3Vector = plg::vector (*)(); - using FuncVec4Vector = plg::vector (*)(); - using FuncMat4x4Vector = plg::vector (*)(); - using FuncVec2 = plg::vec2 (*)(); - using FuncVec3 = plg::vec3 (*)(); - using FuncVec4 = plg::vec4 (*)(); - using FuncMat4x4 = plg::mat4x4 (*)(); - using Func1 = int32_t (*)(const plg::vec3 &); - using Func2 = char (*)(float, int64_t); - using Func3 = void (*)(void *, const plg::vec4 &, const plg::string &); - using Func4 = plg::vec4 (*)(bool, int32_t, char16_t, const plg::mat4x4 &); - using Func5 = bool (*)(int8_t, const plg::vec2 &, void *, double, const plg::vector &); - using Func6 = int64_t (*)(const plg::string &, float, const plg::vector &, int16_t, - const plg::vector &, void *); - using Func7 = double (*)(const plg::vector &, uint16_t, char16_t, const plg::vector &, - const plg::vec4 &, bool, uint64_t); - using Func8 = plg::mat4x4 (*)(const plg::vec3 &, const plg::vector &, int16_t, bool, const plg::vec4 &, - const plg::vector &, char16_t, int32_t); - using Func9 = void (*)(float, const plg::vec2 &, const plg::vector &, uint64_t, bool, const plg::string &, - const plg::vec4 &, int16_t, void *); - using Func10 = uint32_t (*)(const plg::vec4 &, const plg::mat4x4 &, const plg::vector &, uint64_t, - const plg::vector &, int32_t, bool, const plg::vec2 &, int64_t, double); - using Func11 = void* (*)(const plg::vector &, char16_t, uint8_t, double, const plg::vec3 &, - const plg::vector &, int64_t, uint16_t, float, const plg::vec2 &, uint32_t); - using Func12 = bool (*)(void *, const plg::vector &, uint32_t, double, bool, int32_t, int8_t, uint64_t, - float, const plg::vector &, int64_t, char); - using Func13 = plg::string (*)(int64_t, const plg::vector &, uint16_t, float, const plg::vector &, - const plg::vec4 &, const plg::string &, int32_t, const plg::vec3 &, void *, - const plg::vec2 &, const plg::vector &, int16_t); - using Func14 = plg::vector (*)(const plg::vector &, const plg::vector &, - const plg::mat4x4 &, bool, char16_t, int32_t, - const plg::vector &, uint16_t, const plg::vector &, - int8_t, const plg::vec3 &, const plg::vec4 &, double, void *); - using Func15 = int16_t (*)(const plg::vector &, const plg::mat4x4 &, const plg::vec4 &, void *, uint64_t, - const plg::vector &, bool, float, const plg::vector &, uint8_t, - int32_t, const plg::vec2 &, uint16_t, double, const plg::vector &); - using Func16 = void* (*)(const plg::vector &, int16_t, const plg::vector &, const plg::vec4 &, - const plg::mat4x4 &, const plg::vec2 &, const plg::vector &, - const plg::vector &, const plg::string &, int64_t, const plg::vector &, - const plg::vec3 &, float, double, int8_t, uint16_t); - using Func17 = void (*)(int32_t &); - using Func18 = plg::vec2 (*)(int8_t &, int16_t &); - using Func19 = void (*)(uint32_t &, plg::vec3 &, plg::vector &); - using Func20 = int32_t (*)(char16_t &, plg::vec4 &, plg::vector &, char &); - using Func21 = float (*)(plg::mat4x4 &, plg::vector &, plg::vec2 &, bool &, double &); - using Func22 = uint64_t (*)(void *&, uint32_t &, plg::vector &, int16_t &, plg::string &, plg::vec4 &); - using Func23 = void (*)(uint64_t &, plg::vec2 &, plg::vector &, char16_t &, float &, int8_t &, - plg::vector &); - using Func24 = plg::mat4x4 (*)(plg::vector &, int64_t &, plg::vector &, plg::vec4 &, uint64_t &, - plg::vector &, double &, plg::vector &); - using Func25 = double (*)(int32_t &, plg::vector &, bool &, uint8_t &, plg::string &, plg::vec3 &, - int64_t &, plg::vec4 &, uint16_t &); - using Func26 = char (*)(char16_t &, plg::vec2 &, plg::mat4x4 &, plg::vector &, int16_t &, uint64_t &, - uint32_t &, plg::vector &, void *&, bool &); - using Func27 = uint8_t (*)(float &, plg::vec3 &, void *&, plg::vec2 &, plg::vector &, plg::mat4x4 &, - bool &, plg::vec4 &, int8_t &, int32_t &, plg::vector &); - using Func28 = plg::string (*)(void *&, uint16_t &, plg::vector &, plg::mat4x4 &, float &, plg::vec4 &, - plg::string &, plg::vector &, int64_t &, bool &, plg::vec3 &, - plg::vector &); - using Func29 = plg::vector (*)(plg::vec4 &, int32_t &, plg::vector &, double &, bool &, - int8_t &, plg::vector &, float &, plg::string &, - plg::mat4x4 &, uint64_t &, plg::vec3 &, plg::vector &); - using Func30 = int32_t (*)(void *&, plg::vec4 &, int64_t &, plg::vector &, bool &, plg::string &, - plg::vec3 &, plg::vector &, float &, plg::vec2 &, plg::mat4x4 &, int8_t &, - plg::vector &, double &); - using Func31 = plg::vec3 (*)(char &, uint32_t &, plg::vector &, plg::vec4 &, plg::string &, bool &, - int64_t &, plg::vec2 &, int8_t &, uint16_t &, plg::vector &, plg::mat4x4 &, - plg::vec3 &, float &, plg::vector &); - using Func32 = double (*)(int32_t &, uint16_t &, plg::vector &, plg::vec4 &, void *&, - plg::vector &, plg::mat4x4 &, uint64_t &, plg::string &, int64_t &, plg::vec2 &, - plg::vector &, bool &, plg::vec3 &, uint8_t &, plg::vector &); - using Func33 = void (*)(plg::any &); - using FuncEnum = plg::vector (*)(Example, plg::vector &); - - /** - * @brief No description provided. - * - * @function NoParamReturnVoid - */ - inline void NoParamReturnVoid() { - using NoParamReturnVoidFn = void (*)(); - static NoParamReturnVoidFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnVoid", - reinterpret_cast(&__func)); - __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnBool - * - * @return bool: No description available. - */ - inline bool NoParamReturnBool() { - using NoParamReturnBoolFn = bool (*)(); - static NoParamReturnBoolFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnBool", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnChar8 - * - * @return char8: No description available. - */ - inline char NoParamReturnChar8() { - using NoParamReturnChar8Fn = char (*)(); - static NoParamReturnChar8Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnChar8", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnChar16 - * - * @return char16: No description available. - */ - inline char16_t NoParamReturnChar16() { - using NoParamReturnChar16Fn = char16_t (*)(); - static NoParamReturnChar16Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnChar16", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnInt8 - * - * @return int8: No description available. - */ - inline int8_t NoParamReturnInt8() { - using NoParamReturnInt8Fn = int8_t (*)(); - static NoParamReturnInt8Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnInt8", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnInt16 - * - * @return int16: No description available. - */ - inline int16_t NoParamReturnInt16() { - using NoParamReturnInt16Fn = int16_t (*)(); - static NoParamReturnInt16Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnInt16", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnInt32 - * - * @return int32: No description available. - */ - inline int32_t NoParamReturnInt32() { - using NoParamReturnInt32Fn = int32_t (*)(); - static NoParamReturnInt32Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnInt32", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnInt64 - * - * @return int64: No description available. - */ - inline int64_t NoParamReturnInt64() { - using NoParamReturnInt64Fn = int64_t (*)(); - static NoParamReturnInt64Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnInt64", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnUInt8 - * - * @return uint8: No description available. - */ - inline uint8_t NoParamReturnUInt8() { - using NoParamReturnUInt8Fn = uint8_t (*)(); - static NoParamReturnUInt8Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnUInt8", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnUInt16 - * - * @return uint16: No description available. - */ - inline uint16_t NoParamReturnUInt16() { - using NoParamReturnUInt16Fn = uint16_t (*)(); - static NoParamReturnUInt16Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnUInt16", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnUInt32 - * - * @return uint32: No description available. - */ - inline uint32_t NoParamReturnUInt32() { - using NoParamReturnUInt32Fn = uint32_t (*)(); - static NoParamReturnUInt32Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnUInt32", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnUInt64 - * - * @return uint64: No description available. - */ - inline uint64_t NoParamReturnUInt64() { - using NoParamReturnUInt64Fn = uint64_t (*)(); - static NoParamReturnUInt64Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnUInt64", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnPointer - * - * @return ptr64: No description available. - */ - inline void *NoParamReturnPointer() { - using NoParamReturnPointerFn = void* (*)(); - static NoParamReturnPointerFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnPointer", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnFloat - * - * @return float: No description available. - */ - inline float NoParamReturnFloat() { - using NoParamReturnFloatFn = float (*)(); - static NoParamReturnFloatFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnFloat", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnDouble - * - * @return double: No description available. - */ - inline double NoParamReturnDouble() { - using NoParamReturnDoubleFn = double (*)(); - static NoParamReturnDoubleFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnDouble", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnFunction - * - * @return function: No description available. - */ - inline NoParamReturnFunctionFunc NoParamReturnFunction() { - using NoParamReturnFunctionFn = NoParamReturnFunctionFunc (*)(); - static NoParamReturnFunctionFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnFunction", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnString - * - * @return string: No description available. - */ - inline plg::string NoParamReturnString() { - using NoParamReturnStringFn = plg::string (*)(); - static NoParamReturnStringFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnString", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnAny - * - * @return any: No description available. - */ - inline plg::any NoParamReturnAny() { - using NoParamReturnAnyFn = plg::any (*)(); - static NoParamReturnAnyFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnAny", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayBool - * - * @return bool[]: No description available. - */ - inline plg::vector NoParamReturnArrayBool() { - using NoParamReturnArrayBoolFn = plg::vector (*)(); - static NoParamReturnArrayBoolFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayBool", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayChar8 - * - * @return char8[]: No description available. - */ - inline plg::vector NoParamReturnArrayChar8() { - using NoParamReturnArrayChar8Fn = plg::vector (*)(); - static NoParamReturnArrayChar8Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayChar8", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayChar16 - * - * @return char16[]: No description available. - */ - inline plg::vector NoParamReturnArrayChar16() { - using NoParamReturnArrayChar16Fn = plg::vector (*)(); - static NoParamReturnArrayChar16Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayChar16", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayInt8 - * - * @return int8[]: No description available. - */ - inline plg::vector NoParamReturnArrayInt8() { - using NoParamReturnArrayInt8Fn = plg::vector (*)(); - static NoParamReturnArrayInt8Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayInt8", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayInt16 - * - * @return int16[]: No description available. - */ - inline plg::vector NoParamReturnArrayInt16() { - using NoParamReturnArrayInt16Fn = plg::vector (*)(); - static NoParamReturnArrayInt16Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayInt16", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayInt32 - * - * @return int32[]: No description available. - */ - inline plg::vector NoParamReturnArrayInt32() { - using NoParamReturnArrayInt32Fn = plg::vector (*)(); - static NoParamReturnArrayInt32Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayInt32", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayInt64 - * - * @return int64[]: No description available. - */ - inline plg::vector NoParamReturnArrayInt64() { - using NoParamReturnArrayInt64Fn = plg::vector (*)(); - static NoParamReturnArrayInt64Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayInt64", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayUInt8 - * - * @return uint8[]: No description available. - */ - inline plg::vector NoParamReturnArrayUInt8() { - using NoParamReturnArrayUInt8Fn = plg::vector (*)(); - static NoParamReturnArrayUInt8Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayUInt8", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayUInt16 - * - * @return uint16[]: No description available. - */ - inline plg::vector NoParamReturnArrayUInt16() { - using NoParamReturnArrayUInt16Fn = plg::vector (*)(); - static NoParamReturnArrayUInt16Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayUInt16", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayUInt32 - * - * @return uint32[]: No description available. - */ - inline plg::vector NoParamReturnArrayUInt32() { - using NoParamReturnArrayUInt32Fn = plg::vector (*)(); - static NoParamReturnArrayUInt32Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayUInt32", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayUInt64 - * - * @return uint64[]: No description available. - */ - inline plg::vector NoParamReturnArrayUInt64() { - using NoParamReturnArrayUInt64Fn = plg::vector (*)(); - static NoParamReturnArrayUInt64Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayUInt64", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayPointer - * - * @return ptr64[]: No description available. - */ - inline plg::vector NoParamReturnArrayPointer() { - using NoParamReturnArrayPointerFn = plg::vector (*)(); - static NoParamReturnArrayPointerFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayPointer", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayFloat - * - * @return float[]: No description available. - */ - inline plg::vector NoParamReturnArrayFloat() { - using NoParamReturnArrayFloatFn = plg::vector (*)(); - static NoParamReturnArrayFloatFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayFloat", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayDouble - * - * @return double[]: No description available. - */ - inline plg::vector NoParamReturnArrayDouble() { - using NoParamReturnArrayDoubleFn = plg::vector (*)(); - static NoParamReturnArrayDoubleFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayDouble", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayString - * - * @return string[]: No description available. - */ - inline plg::vector NoParamReturnArrayString() { - using NoParamReturnArrayStringFn = plg::vector (*)(); - static NoParamReturnArrayStringFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayString", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayAny - * - * @return any[]: No description available. - */ - inline plg::vector NoParamReturnArrayAny() { - using NoParamReturnArrayAnyFn = plg::vector (*)(); - static NoParamReturnArrayAnyFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayAny", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayVector2 - * - * @return vec2[]: No description available. - */ - inline plg::vector NoParamReturnArrayVector2() { - using NoParamReturnArrayVector2Fn = plg::vector (*)(); - static NoParamReturnArrayVector2Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayVector2", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayVector3 - * - * @return vec3[]: No description available. - */ - inline plg::vector NoParamReturnArrayVector3() { - using NoParamReturnArrayVector3Fn = plg::vector (*)(); - static NoParamReturnArrayVector3Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayVector3", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayVector4 - * - * @return vec4[]: No description available. - */ - inline plg::vector NoParamReturnArrayVector4() { - using NoParamReturnArrayVector4Fn = plg::vector (*)(); - static NoParamReturnArrayVector4Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayVector4", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnArrayMatrix4x4 - * - * @return mat4x4[]: No description available. - */ - inline plg::vector NoParamReturnArrayMatrix4x4() { - using NoParamReturnArrayMatrix4x4Fn = plg::vector (*)(); - static NoParamReturnArrayMatrix4x4Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnArrayMatrix4x4", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnVector2 - * - * @return vec2: No description available. - */ - inline plg::vec2 NoParamReturnVector2() { - using NoParamReturnVector2Fn = plg::vec2 (*)(); - static NoParamReturnVector2Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnVector2", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnVector3 - * - * @return vec3: No description available. - */ - inline plg::vec3 NoParamReturnVector3() { - using NoParamReturnVector3Fn = plg::vec3 (*)(); - static NoParamReturnVector3Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnVector3", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnVector4 - * - * @return vec4: No description available. - */ - inline plg::vec4 NoParamReturnVector4() { - using NoParamReturnVector4Fn = plg::vec4 (*)(); - static NoParamReturnVector4Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnVector4", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function NoParamReturnMatrix4x4 - * - * @return mat4x4: No description available. - */ - inline plg::mat4x4 NoParamReturnMatrix4x4() { - using NoParamReturnMatrix4x4Fn = plg::mat4x4 (*)(); - static NoParamReturnMatrix4x4Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.NoParamReturnMatrix4x4", - reinterpret_cast(&__func)); - return __func(); - } - - /** - * @brief No description provided. - * - * @function Param1 - * @param a (int32): No description available. - */ - inline void Param1(int32_t a) { - using Param1Fn = void (*)(int32_t); - static Param1Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.Param1", reinterpret_cast(&__func)); - __func(a); - } - - /** - * @brief No description provided. - * - * @function Param2 - * @param a (int32): No description available. - * @param b (float): No description available. - */ - inline void Param2(int32_t a, float b) { - using Param2Fn = void (*)(int32_t, float); - static Param2Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.Param2", reinterpret_cast(&__func)); - __func(a, b); - } - - /** - * @brief No description provided. - * - * @function Param3 - * @param a (int32): No description available. - * @param b (float): No description available. - * @param c (double): No description available. - */ - inline void Param3(int32_t a, float b, double c) { - using Param3Fn = void (*)(int32_t, float, double); - static Param3Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.Param3", reinterpret_cast(&__func)); - __func(a, b, c); - } - - /** - * @brief No description provided. - * - * @function Param4 - * @param a (int32): No description available. - * @param b (float): No description available. - * @param c (double): No description available. - * @param d (vec4): No description available. - */ - inline void Param4(int32_t a, float b, double c, const plg::vec4 &d) { - using Param4Fn = void (*)(int32_t, float, double, const plg::vec4 &); - static Param4Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.Param4", reinterpret_cast(&__func)); - __func(a, b, c, d); - } - - /** - * @brief No description provided. - * - * @function Param5 - * @param a (int32): No description available. - * @param b (float): No description available. - * @param c (double): No description available. - * @param d (vec4): No description available. - * @param e (int64[]): No description available. - */ - inline void Param5(int32_t a, float b, double c, const plg::vec4 &d, const plg::vector &e) { - using Param5Fn = void (*)(int32_t, float, double, const plg::vec4 &, const plg::vector &); - static Param5Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.Param5", reinterpret_cast(&__func)); - __func(a, b, c, d, e); - } - - /** - * @brief No description provided. - * - * @function Param6 - * @param a (int32): No description available. - * @param b (float): No description available. - * @param c (double): No description available. - * @param d (vec4): No description available. - * @param e (int64[]): No description available. - * @param f (char8): No description available. - */ - inline void Param6(int32_t a, float b, double c, const plg::vec4 &d, const plg::vector &e, char f) { - using Param6Fn = void (*)(int32_t, float, double, const plg::vec4 &, const plg::vector &, char); - static Param6Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.Param6", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f); - } - - /** - * @brief No description provided. - * - * @function Param7 - * @param a (int32): No description available. - * @param b (float): No description available. - * @param c (double): No description available. - * @param d (vec4): No description available. - * @param e (int64[]): No description available. - * @param f (char8): No description available. - * @param g (string): No description available. - */ - inline void Param7(int32_t a, float b, double c, const plg::vec4 &d, const plg::vector &e, char f, - const plg::string &g) { - using Param7Fn = void (*)(int32_t, float, double, const plg::vec4 &, const plg::vector &, char, - const plg::string &); - static Param7Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.Param7", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f, g); - } - - /** - * @brief No description provided. - * - * @function Param8 - * @param a (int32): No description available. - * @param b (float): No description available. - * @param c (double): No description available. - * @param d (vec4): No description available. - * @param e (int64[]): No description available. - * @param f (char8): No description available. - * @param g (string): No description available. - * @param h (char16): No description available. - */ - inline void Param8(int32_t a, float b, double c, const plg::vec4 &d, const plg::vector &e, char f, - const plg::string &g, char16_t h) { - using Param8Fn = void (*)(int32_t, float, double, const plg::vec4 &, const plg::vector &, char, - const plg::string &, char16_t); - static Param8Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.Param8", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f, g, h); - } - - /** - * @brief No description provided. - * - * @function Param9 - * @param a (int32): No description available. - * @param b (float): No description available. - * @param c (double): No description available. - * @param d (vec4): No description available. - * @param e (int64[]): No description available. - * @param f (char8): No description available. - * @param g (string): No description available. - * @param h (char16): No description available. - * @param k (int16): No description available. - */ - inline void Param9(int32_t a, float b, double c, const plg::vec4 &d, const plg::vector &e, char f, - const plg::string &g, char16_t h, int16_t k) { - using Param9Fn = void (*)(int32_t, float, double, const plg::vec4 &, const plg::vector &, char, - const plg::string &, char16_t, int16_t); - static Param9Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.Param9", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f, g, h, k); - } - - /** - * @brief No description provided. - * - * @function Param10 - * @param a (int32): No description available. - * @param b (float): No description available. - * @param c (double): No description available. - * @param d (vec4): No description available. - * @param e (int64[]): No description available. - * @param f (char8): No description available. - * @param g (string): No description available. - * @param h (char16): No description available. - * @param k (int16): No description available. - * @param l (ptr64): No description available. - */ - inline void Param10(int32_t a, float b, double c, const plg::vec4 &d, const plg::vector &e, char f, - const plg::string &g, char16_t h, int16_t k, void *l) { - using Param10Fn = void (*)(int32_t, float, double, const plg::vec4 &, const plg::vector &, char, - const plg::string &, char16_t, int16_t, void *); - static Param10Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.Param10", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f, g, h, k, l); - } - - /** - * @brief No description provided. - * - * @function ParamRef1 - * @param a (int32): No description available. - */ - inline void ParamRef1(int32_t &a) { - using ParamRef1Fn = void (*)(int32_t &); - static ParamRef1Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.ParamRef1", reinterpret_cast(&__func)); - __func(a); - } - - /** - * @brief No description provided. - * - * @function ParamRef2 - * @param a (int32): No description available. - * @param b (float): No description available. - */ - inline void ParamRef2(int32_t &a, float &b) { - using ParamRef2Fn = void (*)(int32_t &, float &); - static ParamRef2Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.ParamRef2", reinterpret_cast(&__func)); - __func(a, b); - } - - /** - * @brief No description provided. - * - * @function ParamRef3 - * @param a (int32): No description available. - * @param b (float): No description available. - * @param c (double): No description available. - */ - inline void ParamRef3(int32_t &a, float &b, double &c) { - using ParamRef3Fn = void (*)(int32_t &, float &, double &); - static ParamRef3Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.ParamRef3", reinterpret_cast(&__func)); - __func(a, b, c); - } - - /** - * @brief No description provided. - * - * @function ParamRef4 - * @param a (int32): No description available. - * @param b (float): No description available. - * @param c (double): No description available. - * @param d (vec4): No description available. - */ - inline void ParamRef4(int32_t &a, float &b, double &c, plg::vec4 &d) { - using ParamRef4Fn = void (*)(int32_t &, float &, double &, plg::vec4 &); - static ParamRef4Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.ParamRef4", reinterpret_cast(&__func)); - __func(a, b, c, d); - } - - /** - * @brief No description provided. - * - * @function ParamRef5 - * @param a (int32): No description available. - * @param b (float): No description available. - * @param c (double): No description available. - * @param d (vec4): No description available. - * @param e (int64[]): No description available. - */ - inline void ParamRef5(int32_t &a, float &b, double &c, plg::vec4 &d, plg::vector &e) { - using ParamRef5Fn = void (*)(int32_t &, float &, double &, plg::vec4 &, plg::vector &); - static ParamRef5Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.ParamRef5", reinterpret_cast(&__func)); - __func(a, b, c, d, e); - } - - /** - * @brief No description provided. - * - * @function ParamRef6 - * @param a (int32): No description available. - * @param b (float): No description available. - * @param c (double): No description available. - * @param d (vec4): No description available. - * @param e (int64[]): No description available. - * @param f (char8): No description available. - */ - inline void ParamRef6(int32_t &a, float &b, double &c, plg::vec4 &d, plg::vector &e, char &f) { - using ParamRef6Fn = void (*)(int32_t &, float &, double &, plg::vec4 &, plg::vector &, char &); - static ParamRef6Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.ParamRef6", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f); - } - - /** - * @brief No description provided. - * - * @function ParamRef7 - * @param a (int32): No description available. - * @param b (float): No description available. - * @param c (double): No description available. - * @param d (vec4): No description available. - * @param e (int64[]): No description available. - * @param f (char8): No description available. - * @param g (string): No description available. - */ - inline void ParamRef7(int32_t &a, float &b, double &c, plg::vec4 &d, plg::vector &e, char &f, - plg::string &g) { - using ParamRef7Fn = void (*)(int32_t &, float &, double &, plg::vec4 &, plg::vector &, char &, - plg::string &); - static ParamRef7Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.ParamRef7", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f, g); - } - - /** - * @brief No description provided. - * - * @function ParamRef8 - * @param a (int32): No description available. - * @param b (float): No description available. - * @param c (double): No description available. - * @param d (vec4): No description available. - * @param e (int64[]): No description available. - * @param f (char8): No description available. - * @param g (string): No description available. - * @param h (char16): No description available. - */ - inline void ParamRef8(int32_t &a, float &b, double &c, plg::vec4 &d, plg::vector &e, char &f, - plg::string &g, char16_t &h) { - using ParamRef8Fn = void (*)(int32_t &, float &, double &, plg::vec4 &, plg::vector &, char &, - plg::string &, char16_t &); - static ParamRef8Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.ParamRef8", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f, g, h); - } - - /** - * @brief No description provided. - * - * @function ParamRef9 - * @param a (int32): No description available. - * @param b (float): No description available. - * @param c (double): No description available. - * @param d (vec4): No description available. - * @param e (int64[]): No description available. - * @param f (char8): No description available. - * @param g (string): No description available. - * @param h (char16): No description available. - * @param k (int16): No description available. - */ - inline void ParamRef9(int32_t &a, float &b, double &c, plg::vec4 &d, plg::vector &e, char &f, - plg::string &g, char16_t &h, int16_t &k) { - using ParamRef9Fn = void (*)(int32_t &, float &, double &, plg::vec4 &, plg::vector &, char &, - plg::string &, char16_t &, int16_t &); - static ParamRef9Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.ParamRef9", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f, g, h, k); - } - - /** - * @brief No description provided. - * - * @function ParamRef10 - * @param a (int32): No description available. - * @param b (float): No description available. - * @param c (double): No description available. - * @param d (vec4): No description available. - * @param e (int64[]): No description available. - * @param f (char8): No description available. - * @param g (string): No description available. - * @param h (char16): No description available. - * @param k (int16): No description available. - * @param l (ptr64): No description available. - */ - inline void ParamRef10(int32_t &a, float &b, double &c, plg::vec4 &d, plg::vector &e, char &f, - plg::string &g, char16_t &h, int16_t &k, void *&l) { - using ParamRef10Fn = void (*)(int32_t &, float &, double &, plg::vec4 &, plg::vector &, char &, - plg::string &, char16_t &, int16_t &, void *&); - static ParamRef10Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.ParamRef10", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f, g, h, k, l); - } - - /** - * @brief No description provided. - * - * @function ParamRefVectors - * @param p1 (bool[]): No description available. - * @param p2 (char8[]): No description available. - * @param p3 (char16[]): No description available. - * @param p4 (int8[]): No description available. - * @param p5 (int16[]): No description available. - * @param p6 (int32[]): No description available. - * @param p7 (int64[]): No description available. - * @param p8 (uint8[]): No description available. - * @param p9 (uint16[]): No description available. - * @param p10 (uint32[]): No description available. - * @param p11 (uint64[]): No description available. - * @param p12 (ptr64[]): No description available. - * @param p13 (float[]): No description available. - * @param p14 (double[]): No description available. - * @param p15 (string[]): No description available. - */ - inline void ParamRefVectors(plg::vector &p1, plg::vector &p2, plg::vector &p3, - plg::vector &p4, plg::vector &p5, plg::vector &p6, - plg::vector &p7, plg::vector &p8, plg::vector &p9, - plg::vector &p10, plg::vector &p11, plg::vector &p12, - plg::vector &p13, plg::vector &p14, plg::vector &p15) { - using ParamRefVectorsFn = void (*)(plg::vector &, plg::vector &, plg::vector &, - plg::vector &, plg::vector &, plg::vector &, - plg::vector &, plg::vector &, plg::vector &, - plg::vector &, plg::vector &, plg::vector &, - plg::vector &, plg::vector &, plg::vector &); - static ParamRefVectorsFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.ParamRefVectors", - reinterpret_cast(&__func)); - __func(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); - } - - /** - * @brief No description provided. - * - * @function ParamAllPrimitives - * @param p1 (bool): No description available. - * @param p2 (char8): No description available. - * @param p3 (char16): No description available. - * @param p4 (int8): No description available. - * @param p5 (int16): No description available. - * @param p6 (int32): No description available. - * @param p7 (int64): No description available. - * @param p8 (uint8): No description available. - * @param p9 (uint16): No description available. - * @param p10 (uint32): No description available. - * @param p11 (uint64): No description available. - * @param p12 (ptr64): No description available. - * @param p13 (float): No description available. - * @param p14 (double): No description available. - * - * @return int64: No description available. - */ - inline int64_t ParamAllPrimitives(bool p1, char p2, char16_t p3, int8_t p4, int16_t p5, int32_t p6, int64_t p7, - uint8_t p8, uint16_t p9, uint32_t p10, uint64_t p11, void *p12, float p13, - double p14) { - using ParamAllPrimitivesFn = int64_t (*)(bool, char, char16_t, int8_t, int16_t, int32_t, int64_t, uint8_t, - uint16_t, uint32_t, uint64_t, void *, float, double); - static ParamAllPrimitivesFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.ParamAllPrimitives", - reinterpret_cast(&__func)); - return __func(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); - } - - /** - * @brief No description provided. - * - * @function ParamVariant - * @param p1 (any): No description available. - * @param p2 (any[]): No description available. - */ - inline void ParamVariant(const plg::any &p1, const plg::vector &p2) { - using ParamVariantFn = void (*)(const plg::any &, const plg::vector &); - static ParamVariantFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.ParamVariant", reinterpret_cast(&__func)); - __func(p1, p2); - } - - /** - * @brief No description provided. - * - * @function ParamEnum - * @param p1 (int32): No description available. - * @param p2 (int32[]): No description available. - * - * @return int32: No description available. - */ - inline int32_t ParamEnum(Example p1, const plg::vector &p2) { - using ParamEnumFn = int32_t (*)(Example, const plg::vector &); - static ParamEnumFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.ParamEnum", reinterpret_cast(&__func)); - return __func(p1, p2); - } - - /** - * @brief No description provided. - * - * @function ParamEnumRef - * @param p1 (int32): No description available. - * @param p2 (int32[]): No description available. - * - * @return int32: No description available. - */ - inline int32_t ParamEnumRef(Example &p1, plg::vector &p2) { - using ParamEnumRefFn = int32_t (*)(Example &, plg::vector &); - static ParamEnumRefFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.ParamEnumRef", reinterpret_cast(&__func)); - return __func(p1, p2); - } - - /** - * @brief No description provided. - * - * @function ParamVariantRef - * @param p1 (any): No description available. - * @param p2 (any[]): No description available. - */ - inline void ParamVariantRef(plg::any &p1, plg::vector &p2) { - using ParamVariantRefFn = void (*)(plg::any &, plg::vector &); - static ParamVariantRefFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.ParamVariantRef", - reinterpret_cast(&__func)); - __func(p1, p2); - } - - /** - * @brief No description provided. - * - * @function CallFuncVoid - * @param func (function): No description available. - * - * @callback FuncVoid - * @brief No description provided. - * - * - * @return (callback): void: No description available. - */ - inline void CallFuncVoid(FuncVoid func) { - using CallFuncVoidFn = void (*)(FuncVoid); - static CallFuncVoidFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncVoid", reinterpret_cast(&__func)); - __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncBool - * @param func (function): No description available. - * - * @return bool: No description available. - * - * @callback FuncBool - * @brief No description provided. - * - * - * @return (callback): bool: No description available. - */ - inline bool CallFuncBool(FuncBool func) { - using CallFuncBoolFn = bool (*)(FuncBool); - static CallFuncBoolFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncBool", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncChar8 - * @param func (function): No description available. - * - * @return char8: No description available. - * - * @callback FuncChar8 - * @brief No description provided. - * - * - * @return (callback): char8: No description available. - */ - inline char CallFuncChar8(FuncChar8 func) { - using CallFuncChar8Fn = char (*)(FuncChar8); - static CallFuncChar8Fn __func = nullptr; - if (__func == nullptr) - plg::GetMethodPtr2("cross_call_worker.CallFuncChar8", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncChar16 - * @param func (function): No description available. - * - * @return char16: No description available. - * - * @callback FuncChar16 - * @brief No description provided. - * - * - * @return (callback): char16: No description available. - */ - inline char16_t CallFuncChar16(FuncChar16 func) { - using CallFuncChar16Fn = char16_t (*)(FuncChar16); - static CallFuncChar16Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncChar16", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncInt8 - * @param func (function): No description available. - * - * @return int8: No description available. - * - * @callback FuncInt8 - * @brief No description provided. - * - * - * @return (callback): int8: No description available. - */ - inline int8_t CallFuncInt8(FuncInt8 func) { - using CallFuncInt8Fn = int8_t (*)(FuncInt8); - static CallFuncInt8Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncInt8", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncInt16 - * @param func (function): No description available. - * - * @return int16: No description available. - * - * @callback FuncInt16 - * @brief No description provided. - * - * - * @return (callback): int16: No description available. - */ - inline int16_t CallFuncInt16(FuncInt16 func) { - using CallFuncInt16Fn = int16_t (*)(FuncInt16); - static CallFuncInt16Fn __func = nullptr; - if (__func == nullptr) - plg::GetMethodPtr2("cross_call_worker.CallFuncInt16", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncInt32 - * @param func (function): No description available. - * - * @return int32: No description available. - * - * @callback FuncInt32 - * @brief No description provided. - * - * - * @return (callback): int32: No description available. - */ - inline int32_t CallFuncInt32(FuncInt32 func) { - using CallFuncInt32Fn = int32_t (*)(FuncInt32); - static CallFuncInt32Fn __func = nullptr; - if (__func == nullptr) - plg::GetMethodPtr2("cross_call_worker.CallFuncInt32", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncInt64 - * @param func (function): No description available. - * - * @return int64: No description available. - * - * @callback FuncInt64 - * @brief No description provided. - * - * - * @return (callback): int64: No description available. - */ - inline int64_t CallFuncInt64(FuncInt64 func) { - using CallFuncInt64Fn = int64_t (*)(FuncInt64); - static CallFuncInt64Fn __func = nullptr; - if (__func == nullptr) - plg::GetMethodPtr2("cross_call_worker.CallFuncInt64", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncUInt8 - * @param func (function): No description available. - * - * @return uint8: No description available. - * - * @callback FuncUInt8 - * @brief No description provided. - * - * - * @return (callback): uint8: No description available. - */ - inline uint8_t CallFuncUInt8(FuncUInt8 func) { - using CallFuncUInt8Fn = uint8_t (*)(FuncUInt8); - static CallFuncUInt8Fn __func = nullptr; - if (__func == nullptr) - plg::GetMethodPtr2("cross_call_worker.CallFuncUInt8", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncUInt16 - * @param func (function): No description available. - * - * @return uint16: No description available. - * - * @callback FuncUInt16 - * @brief No description provided. - * - * - * @return (callback): uint16: No description available. - */ - inline uint16_t CallFuncUInt16(FuncUInt16 func) { - using CallFuncUInt16Fn = uint16_t (*)(FuncUInt16); - static CallFuncUInt16Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncUInt16", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncUInt32 - * @param func (function): No description available. - * - * @return uint32: No description available. - * - * @callback FuncUInt32 - * @brief No description provided. - * - * - * @return (callback): uint32: No description available. - */ - inline uint32_t CallFuncUInt32(FuncUInt32 func) { - using CallFuncUInt32Fn = uint32_t (*)(FuncUInt32); - static CallFuncUInt32Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncUInt32", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncUInt64 - * @param func (function): No description available. - * - * @return uint64: No description available. - * - * @callback FuncUInt64 - * @brief No description provided. - * - * - * @return (callback): uint64: No description available. - */ - inline uint64_t CallFuncUInt64(FuncUInt64 func) { - using CallFuncUInt64Fn = uint64_t (*)(FuncUInt64); - static CallFuncUInt64Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncUInt64", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncPtr - * @param func (function): No description available. - * - * @return ptr64: No description available. - * - * @callback FuncPtr - * @brief No description provided. - * - * - * @return (callback): ptr64: No description available. - */ - inline void *CallFuncPtr(FuncPtr func) { - using CallFuncPtrFn = void* (*)(FuncPtr); - static CallFuncPtrFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncPtr", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncFloat - * @param func (function): No description available. - * - * @return float: No description available. - * - * @callback FuncFloat - * @brief No description provided. - * - * - * @return (callback): float: No description available. - */ - inline float CallFuncFloat(FuncFloat func) { - using CallFuncFloatFn = float (*)(FuncFloat); - static CallFuncFloatFn __func = nullptr; - if (__func == nullptr) - plg::GetMethodPtr2("cross_call_worker.CallFuncFloat", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncDouble - * @param func (function): No description available. - * - * @return double: No description available. - * - * @callback FuncDouble - * @brief No description provided. - * - * - * @return (callback): double: No description available. - */ - inline double CallFuncDouble(FuncDouble func) { - using CallFuncDoubleFn = double (*)(FuncDouble); - static CallFuncDoubleFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncDouble", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncString - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback FuncString - * @brief No description provided. - * - * - * @return (callback): string: No description available. - */ - inline plg::string CallFuncString(FuncString func) { - using CallFuncStringFn = plg::string (*)(FuncString); - static CallFuncStringFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncString", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncAny - * @param func (function): No description available. - * - * @return any: No description available. - * - * @callback FuncAny - * @brief No description provided. - * - * - * @return (callback): any: No description available. - */ - inline plg::any CallFuncAny(FuncAny func) { - using CallFuncAnyFn = plg::any (*)(FuncAny); - static CallFuncAnyFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncAny", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncFunction - * @param func (function): No description available. - * - * @return ptr64: No description available. - * - * @callback FuncFunction - * @brief No description provided. - * - * - * @return (callback): function: No description available. - */ - inline void *CallFuncFunction(FuncFunction func) { - using CallFuncFunctionFn = void* (*)(FuncFunction); - static CallFuncFunctionFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncFunction", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncBoolVector - * @param func (function): No description available. - * - * @return bool[]: No description available. - * - * @callback FuncBoolVector - * @brief No description provided. - * - * - * @return (callback): bool[]: No description available. - */ - inline plg::vector CallFuncBoolVector(FuncBoolVector func) { - using CallFuncBoolVectorFn = plg::vector (*)(FuncBoolVector); - static CallFuncBoolVectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncBoolVector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncChar8Vector - * @param func (function): No description available. - * - * @return char8[]: No description available. - * - * @callback FuncChar8Vector - * @brief No description provided. - * - * - * @return (callback): char8[]: No description available. - */ - inline plg::vector CallFuncChar8Vector(FuncChar8Vector func) { - using CallFuncChar8VectorFn = plg::vector (*)(FuncChar8Vector); - static CallFuncChar8VectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncChar8Vector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncChar16Vector - * @param func (function): No description available. - * - * @return char16[]: No description available. - * - * @callback FuncChar16Vector - * @brief No description provided. - * - * - * @return (callback): char16[]: No description available. - */ - inline plg::vector CallFuncChar16Vector(FuncChar16Vector func) { - using CallFuncChar16VectorFn = plg::vector (*)(FuncChar16Vector); - static CallFuncChar16VectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncChar16Vector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncInt8Vector - * @param func (function): No description available. - * - * @return int8[]: No description available. - * - * @callback FuncInt8Vector - * @brief No description provided. - * - * - * @return (callback): int8[]: No description available. - */ - inline plg::vector CallFuncInt8Vector(FuncInt8Vector func) { - using CallFuncInt8VectorFn = plg::vector (*)(FuncInt8Vector); - static CallFuncInt8VectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncInt8Vector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncInt16Vector - * @param func (function): No description available. - * - * @return int16[]: No description available. - * - * @callback FuncInt16Vector - * @brief No description provided. - * - * - * @return (callback): int16[]: No description available. - */ - inline plg::vector CallFuncInt16Vector(FuncInt16Vector func) { - using CallFuncInt16VectorFn = plg::vector (*)(FuncInt16Vector); - static CallFuncInt16VectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncInt16Vector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncInt32Vector - * @param func (function): No description available. - * - * @return int32[]: No description available. - * - * @callback FuncInt32Vector - * @brief No description provided. - * - * - * @return (callback): int32[]: No description available. - */ - inline plg::vector CallFuncInt32Vector(FuncInt32Vector func) { - using CallFuncInt32VectorFn = plg::vector (*)(FuncInt32Vector); - static CallFuncInt32VectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncInt32Vector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncInt64Vector - * @param func (function): No description available. - * - * @return int64[]: No description available. - * - * @callback FuncInt64Vector - * @brief No description provided. - * - * - * @return (callback): int64[]: No description available. - */ - inline plg::vector CallFuncInt64Vector(FuncInt64Vector func) { - using CallFuncInt64VectorFn = plg::vector (*)(FuncInt64Vector); - static CallFuncInt64VectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncInt64Vector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncUInt8Vector - * @param func (function): No description available. - * - * @return uint8[]: No description available. - * - * @callback FuncUInt8Vector - * @brief No description provided. - * - * - * @return (callback): uint8[]: No description available. - */ - inline plg::vector CallFuncUInt8Vector(FuncUInt8Vector func) { - using CallFuncUInt8VectorFn = plg::vector (*)(FuncUInt8Vector); - static CallFuncUInt8VectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncUInt8Vector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncUInt16Vector - * @param func (function): No description available. - * - * @return uint16[]: No description available. - * - * @callback FuncUInt16Vector - * @brief No description provided. - * - * - * @return (callback): uint16[]: No description available. - */ - inline plg::vector CallFuncUInt16Vector(FuncUInt16Vector func) { - using CallFuncUInt16VectorFn = plg::vector (*)(FuncUInt16Vector); - static CallFuncUInt16VectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncUInt16Vector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncUInt32Vector - * @param func (function): No description available. - * - * @return uint32[]: No description available. - * - * @callback FuncUInt32Vector - * @brief No description provided. - * - * - * @return (callback): uint32[]: No description available. - */ - inline plg::vector CallFuncUInt32Vector(FuncUInt32Vector func) { - using CallFuncUInt32VectorFn = plg::vector (*)(FuncUInt32Vector); - static CallFuncUInt32VectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncUInt32Vector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncUInt64Vector - * @param func (function): No description available. - * - * @return uint64[]: No description available. - * - * @callback FuncUInt64Vector - * @brief No description provided. - * - * - * @return (callback): uint64[]: No description available. - */ - inline plg::vector CallFuncUInt64Vector(FuncUInt64Vector func) { - using CallFuncUInt64VectorFn = plg::vector (*)(FuncUInt64Vector); - static CallFuncUInt64VectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncUInt64Vector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncPtrVector - * @param func (function): No description available. - * - * @return ptr64[]: No description available. - * - * @callback FuncPtrVector - * @brief No description provided. - * - * - * @return (callback): ptr64[]: No description available. - */ - inline plg::vector CallFuncPtrVector(FuncPtrVector func) { - using CallFuncPtrVectorFn = plg::vector (*)(FuncPtrVector); - static CallFuncPtrVectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncPtrVector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncFloatVector - * @param func (function): No description available. - * - * @return float[]: No description available. - * - * @callback FuncFloatVector - * @brief No description provided. - * - * - * @return (callback): float[]: No description available. - */ - inline plg::vector CallFuncFloatVector(FuncFloatVector func) { - using CallFuncFloatVectorFn = plg::vector (*)(FuncFloatVector); - static CallFuncFloatVectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncFloatVector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncDoubleVector - * @param func (function): No description available. - * - * @return double[]: No description available. - * - * @callback FuncDoubleVector - * @brief No description provided. - * - * - * @return (callback): double[]: No description available. - */ - inline plg::vector CallFuncDoubleVector(FuncDoubleVector func) { - using CallFuncDoubleVectorFn = plg::vector (*)(FuncDoubleVector); - static CallFuncDoubleVectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncDoubleVector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncStringVector - * @param func (function): No description available. - * - * @return string[]: No description available. - * - * @callback FuncStringVector - * @brief No description provided. - * - * - * @return (callback): string[]: No description available. - */ - inline plg::vector CallFuncStringVector(FuncStringVector func) { - using CallFuncStringVectorFn = plg::vector (*)(FuncStringVector); - static CallFuncStringVectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncStringVector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncAnyVector - * @param func (function): No description available. - * - * @return any[]: No description available. - * - * @callback FuncAnyVector - * @brief No description provided. - * - * - * @return (callback): any[]: No description available. - */ - inline plg::vector CallFuncAnyVector(FuncAnyVector func) { - using CallFuncAnyVectorFn = plg::vector (*)(FuncAnyVector); - static CallFuncAnyVectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncAnyVector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncVec2Vector - * @param func (function): No description available. - * - * @return vec2[]: No description available. - * - * @callback FuncVec2Vector - * @brief No description provided. - * - * - * @return (callback): vec2[]: No description available. - */ - inline plg::vector CallFuncVec2Vector(FuncVec2Vector func) { - using CallFuncVec2VectorFn = plg::vector (*)(FuncVec2Vector); - static CallFuncVec2VectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncVec2Vector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncVec3Vector - * @param func (function): No description available. - * - * @return vec3[]: No description available. - * - * @callback FuncVec3Vector - * @brief No description provided. - * - * - * @return (callback): vec3[]: No description available. - */ - inline plg::vector CallFuncVec3Vector(FuncVec3Vector func) { - using CallFuncVec3VectorFn = plg::vector (*)(FuncVec3Vector); - static CallFuncVec3VectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncVec3Vector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncVec4Vector - * @param func (function): No description available. - * - * @return vec4[]: No description available. - * - * @callback FuncVec4Vector - * @brief No description provided. - * - * - * @return (callback): vec4[]: No description available. - */ - inline plg::vector CallFuncVec4Vector(FuncVec4Vector func) { - using CallFuncVec4VectorFn = plg::vector (*)(FuncVec4Vector); - static CallFuncVec4VectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncVec4Vector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncMat4x4Vector - * @param func (function): No description available. - * - * @return mat4x4[]: No description available. - * - * @callback FuncMat4x4Vector - * @brief No description provided. - * - * - * @return (callback): mat4x4[]: No description available. - */ - inline plg::vector CallFuncMat4x4Vector(FuncMat4x4Vector func) { - using CallFuncMat4x4VectorFn = plg::vector (*)(FuncMat4x4Vector); - static CallFuncMat4x4VectorFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncMat4x4Vector", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncVec2 - * @param func (function): No description available. - * - * @return vec2: No description available. - * - * @callback FuncVec2 - * @brief No description provided. - * - * - * @return (callback): vec2: No description available. - */ - inline plg::vec2 CallFuncVec2(FuncVec2 func) { - using CallFuncVec2Fn = plg::vec2 (*)(FuncVec2); - static CallFuncVec2Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncVec2", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncVec3 - * @param func (function): No description available. - * - * @return vec3: No description available. - * - * @callback FuncVec3 - * @brief No description provided. - * - * - * @return (callback): vec3: No description available. - */ - inline plg::vec3 CallFuncVec3(FuncVec3 func) { - using CallFuncVec3Fn = plg::vec3 (*)(FuncVec3); - static CallFuncVec3Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncVec3", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncVec4 - * @param func (function): No description available. - * - * @return vec4: No description available. - * - * @callback FuncVec4 - * @brief No description provided. - * - * - * @return (callback): vec4: No description available. - */ - inline plg::vec4 CallFuncVec4(FuncVec4 func) { - using CallFuncVec4Fn = plg::vec4 (*)(FuncVec4); - static CallFuncVec4Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncVec4", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncMat4x4 - * @param func (function): No description available. - * - * @return mat4x4: No description available. - * - * @callback FuncMat4x4 - * @brief No description provided. - * - * - * @return (callback): mat4x4: No description available. - */ - inline plg::mat4x4 CallFuncMat4x4(FuncMat4x4 func) { - using CallFuncMat4x4Fn = plg::mat4x4 (*)(FuncMat4x4); - static CallFuncMat4x4Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncMat4x4", - reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc1 - * @param func (function): No description available. - * - * @return int32: No description available. - * - * @callback Func1 - * @brief No description provided. - * - * @param a (vec3): No description available. - * - * @return (callback): int32: No description available. - */ - inline int32_t CallFunc1(Func1 func) { - using CallFunc1Fn = int32_t (*)(Func1); - static CallFunc1Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc1", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc2 - * @param func (function): No description available. - * - * @return char8: No description available. - * - * @callback Func2 - * @brief No description provided. - * - * @param a (float): No description available. - * @param b (int64): No description available. - * - * @return (callback): char8: No description available. - */ - inline char CallFunc2(Func2 func) { - using CallFunc2Fn = char (*)(Func2); - static CallFunc2Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc2", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc3 - * @param func (function): No description available. - * - * @callback Func3 - * @brief No description provided. - * - * @param a (ptr64): No description available. - * @param b (vec4): No description available. - * @param c (string): No description available. - * - * @return (callback): void: No description available. - */ - inline void CallFunc3(Func3 func) { - using CallFunc3Fn = void (*)(Func3); - static CallFunc3Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc3", reinterpret_cast(&__func)); - __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc4 - * @param func (function): No description available. - * - * @return vec4: No description available. - * - * @callback Func4 - * @brief No description provided. - * - * @param a (bool): No description available. - * @param b (int32): No description available. - * @param c (char16): No description available. - * @param d (mat4x4): No description available. - * - * @return (callback): vec4: No description available. - */ - inline plg::vec4 CallFunc4(Func4 func) { - using CallFunc4Fn = plg::vec4 (*)(Func4); - static CallFunc4Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc4", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc5 - * @param func (function): No description available. - * - * @return bool: No description available. - * - * @callback Func5 - * @brief No description provided. - * - * @param a (int8): No description available. - * @param b (vec2): No description available. - * @param c (ptr64): No description available. - * @param d (double): No description available. - * @param e (uint64[]): No description available. - * - * @return (callback): bool: No description available. - */ - inline bool CallFunc5(Func5 func) { - using CallFunc5Fn = bool (*)(Func5); - static CallFunc5Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc5", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc6 - * @param func (function): No description available. - * - * @return int64: No description available. - * - * @callback Func6 - * @brief No description provided. - * - * @param a (string): No description available. - * @param b (float): No description available. - * @param c (float[]): No description available. - * @param d (int16): No description available. - * @param e (uint8[]): No description available. - * @param f (ptr64): No description available. - * - * @return (callback): int64: No description available. - */ - inline int64_t CallFunc6(Func6 func) { - using CallFunc6Fn = int64_t (*)(Func6); - static CallFunc6Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc6", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc7 - * @param func (function): No description available. - * - * @return double: No description available. - * - * @callback Func7 - * @brief No description provided. - * - * @param vecC (char8[]): No description available. - * @param u16 (uint16): No description available. - * @param ch16 (char16): No description available. - * @param vecU32 (uint32[]): No description available. - * @param vec4 (vec4): No description available. - * @param b (bool): No description available. - * @param u64 (uint64): No description available. - * - * @return (callback): double: No description available. - */ - inline double CallFunc7(Func7 func) { - using CallFunc7Fn = double (*)(Func7); - static CallFunc7Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc7", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc8 - * @param func (function): No description available. - * - * @return mat4x4: No description available. - * - * @callback Func8 - * @brief No description provided. - * - * @param vec3 (vec3): No description available. - * @param vecU32 (uint32[]): No description available. - * @param i16 (int16): No description available. - * @param b (bool): No description available. - * @param vec4 (vec4): No description available. - * @param vecC16 (char16[]): No description available. - * @param ch16 (char16): No description available. - * @param i32 (int32): No description available. - * - * @return (callback): mat4x4: No description available. - */ - inline plg::mat4x4 CallFunc8(Func8 func) { - using CallFunc8Fn = plg::mat4x4 (*)(Func8); - static CallFunc8Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc8", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc9 - * @param func (function): No description available. - * - * @callback Func9 - * @brief No description provided. - * - * @param f (float): No description available. - * @param vec2 (vec2): No description available. - * @param vecI8 (int8[]): No description available. - * @param u64 (uint64): No description available. - * @param b (bool): No description available. - * @param str (string): No description available. - * @param vec4 (vec4): No description available. - * @param i16 (int16): No description available. - * @param ptr (ptr64): No description available. - * - * @return (callback): void: No description available. - */ - inline void CallFunc9(Func9 func) { - using CallFunc9Fn = void (*)(Func9); - static CallFunc9Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc9", reinterpret_cast(&__func)); - __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc10 - * @param func (function): No description available. - * - * @return uint32: No description available. - * - * @callback Func10 - * @brief No description provided. - * - * @param vec4 (vec4): No description available. - * @param mat (mat4x4): No description available. - * @param vecU32 (uint32[]): No description available. - * @param u64 (uint64): No description available. - * @param vecC (char8[]): No description available. - * @param i32 (int32): No description available. - * @param b (bool): No description available. - * @param vec2 (vec2): No description available. - * @param i64 (int64): No description available. - * @param d (double): No description available. - * - * @return (callback): uint32: No description available. - */ - inline uint32_t CallFunc10(Func10 func) { - using CallFunc10Fn = uint32_t (*)(Func10); - static CallFunc10Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc10", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc11 - * @param func (function): No description available. - * - * @return ptr64: No description available. - * - * @callback Func11 - * @brief No description provided. - * - * @param vecB (bool[]): No description available. - * @param ch16 (char16): No description available. - * @param u8 (uint8): No description available. - * @param d (double): No description available. - * @param vec3 (vec3): No description available. - * @param vecI8 (int8[]): No description available. - * @param i64 (int64): No description available. - * @param u16 (uint16): No description available. - * @param f (float): No description available. - * @param vec2 (vec2): No description available. - * @param u32 (uint32): No description available. - * - * @return (callback): ptr64: No description available. - */ - inline void *CallFunc11(Func11 func) { - using CallFunc11Fn = void* (*)(Func11); - static CallFunc11Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc11", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc12 - * @param func (function): No description available. - * - * @return bool: No description available. - * - * @callback Func12 - * @brief No description provided. - * - * @param ptr (ptr64): No description available. - * @param vecD (double[]): No description available. - * @param u32 (uint32): No description available. - * @param d (double): No description available. - * @param b (bool): No description available. - * @param i32 (int32): No description available. - * @param i8 (int8): No description available. - * @param u64 (uint64): No description available. - * @param f (float): No description available. - * @param vecPtr (ptr64[]): No description available. - * @param i64 (int64): No description available. - * @param ch (char8): No description available. - * - * @return (callback): bool: No description available. - */ - inline bool CallFunc12(Func12 func) { - using CallFunc12Fn = bool (*)(Func12); - static CallFunc12Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc12", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc13 - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback Func13 - * @brief No description provided. - * - * @param i64 (int64): No description available. - * @param vecC (char8[]): No description available. - * @param d (uint16): No description available. - * @param f (float): No description available. - * @param b (bool[]): No description available. - * @param vec4 (vec4): No description available. - * @param str (string): No description available. - * @param int32 (int32): No description available. - * @param vec3 (vec3): No description available. - * @param ptr (ptr64): No description available. - * @param vec2 (vec2): No description available. - * @param arr (uint8[]): No description available. - * @param i16 (int16): No description available. - * - * @return (callback): string: No description available. - */ - inline plg::string CallFunc13(Func13 func) { - using CallFunc13Fn = plg::string (*)(Func13); - static CallFunc13Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc13", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc14 - * @param func (function): No description available. - * - * @return string[]: No description available. - * - * @callback Func14 - * @brief No description provided. - * - * @param vecC (char8[]): No description available. - * @param vecU32 (uint32[]): No description available. - * @param mat (mat4x4): No description available. - * @param b (bool): No description available. - * @param ch16 (char16): No description available. - * @param i32 (int32): No description available. - * @param vecF (float[]): No description available. - * @param u16 (uint16): No description available. - * @param vecU8 (uint8[]): No description available. - * @param i8 (int8): No description available. - * @param vec3 (vec3): No description available. - * @param vec4 (vec4): No description available. - * @param d (double): No description available. - * @param ptr (ptr64): No description available. - * - * @return (callback): string[]: No description available. - */ - inline plg::vector CallFunc14(Func14 func) { - using CallFunc14Fn = plg::vector (*)(Func14); - static CallFunc14Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc14", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc15 - * @param func (function): No description available. - * - * @return int16: No description available. - * - * @callback Func15 - * @brief No description provided. - * - * @param vecI16 (int16[]): No description available. - * @param mat (mat4x4): No description available. - * @param vec4 (vec4): No description available. - * @param ptr (ptr64): No description available. - * @param u64 (uint64): No description available. - * @param vecU32 (uint32[]): No description available. - * @param b (bool): No description available. - * @param f (float): No description available. - * @param vecC16 (char16[]): No description available. - * @param u8 (uint8): No description available. - * @param i32 (int32): No description available. - * @param vec2 (vec2): No description available. - * @param u16 (uint16): No description available. - * @param d (double): No description available. - * @param vecU8 (uint8[]): No description available. - * - * @return (callback): int16: No description available. - */ - inline int16_t CallFunc15(Func15 func) { - using CallFunc15Fn = int16_t (*)(Func15); - static CallFunc15Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc15", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc16 - * @param func (function): No description available. - * - * @return ptr64: No description available. - * - * @callback Func16 - * @brief No description provided. - * - * @param vecB (bool[]): No description available. - * @param i16 (int16): No description available. - * @param vecI8 (int8[]): No description available. - * @param vec4 (vec4): No description available. - * @param mat (mat4x4): No description available. - * @param vec2 (vec2): No description available. - * @param vecU64 (uint64[]): No description available. - * @param vecC (char8[]): No description available. - * @param str (string): No description available. - * @param i64 (int64): No description available. - * @param vecU32 (uint32[]): No description available. - * @param vec3 (vec3): No description available. - * @param f (float): No description available. - * @param d (double): No description available. - * @param i8 (int8): No description available. - * @param u16 (uint16): No description available. - * - * @return (callback): ptr64: No description available. - */ - inline void *CallFunc16(Func16 func) { - using CallFunc16Fn = void* (*)(Func16); - static CallFunc16Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc16", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc17 - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback Func17 - * @brief No description provided. - * - * @param i32 (int32): No description available. - * - * @return (callback): void: No description available. - */ - inline plg::string CallFunc17(Func17 func) { - using CallFunc17Fn = plg::string (*)(Func17); - static CallFunc17Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc17", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc18 - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback Func18 - * @brief No description provided. - * - * @param i8 (int8): No description available. - * @param i16 (int16): No description available. - * - * @return (callback): vec2: No description available. - */ - inline plg::string CallFunc18(Func18 func) { - using CallFunc18Fn = plg::string (*)(Func18); - static CallFunc18Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc18", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc19 - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback Func19 - * @brief No description provided. - * - * @param u32 (uint32): No description available. - * @param vec3 (vec3): No description available. - * @param vecU32 (uint32[]): No description available. - * - * @return (callback): void: No description available. - */ - inline plg::string CallFunc19(Func19 func) { - using CallFunc19Fn = plg::string (*)(Func19); - static CallFunc19Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc19", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc20 - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback Func20 - * @brief No description provided. - * - * @param ch16 (char16): No description available. - * @param vec4 (vec4): No description available. - * @param vecU64 (uint64[]): No description available. - * @param ch (char8): No description available. - * - * @return (callback): int32: No description available. - */ - inline plg::string CallFunc20(Func20 func) { - using CallFunc20Fn = plg::string (*)(Func20); - static CallFunc20Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc20", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc21 - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback Func21 - * @brief No description provided. - * - * @param mat (mat4x4): No description available. - * @param vecI32 (int32[]): No description available. - * @param vec2 (vec2): No description available. - * @param b (bool): No description available. - * @param extraParam (double): No description available. - * - * @return (callback): float: No description available. - */ - inline plg::string CallFunc21(Func21 func) { - using CallFunc21Fn = plg::string (*)(Func21); - static CallFunc21Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc21", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc22 - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback Func22 - * @brief No description provided. - * - * @param ptr64Ref (ptr64): No description available. - * @param uint32Ref (uint32): No description available. - * @param vectorDoubleRef (double[]): No description available. - * @param int16Ref (int16): No description available. - * @param plgStringRef (string): No description available. - * @param plgVector4Ref (vec4): No description available. - * - * @return (callback): uint64: No description available. - */ - inline plg::string CallFunc22(Func22 func) { - using CallFunc22Fn = plg::string (*)(Func22); - static CallFunc22Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc22", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc23 - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback Func23 - * @brief No description provided. - * - * @param uint64Ref (uint64): No description available. - * @param plgVector2Ref (vec2): No description available. - * @param vectorInt16Ref (int16[]): No description available. - * @param char16Ref (char16): No description available. - * @param floatRef (float): No description available. - * @param int8Ref (int8): No description available. - * @param vectorUInt8Ref (uint8[]): No description available. - * - * @return (callback): void: No description available. - */ - inline plg::string CallFunc23(Func23 func) { - using CallFunc23Fn = plg::string (*)(Func23); - static CallFunc23Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc23", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc24 - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback Func24 - * @brief No description provided. - * - * @param vectorCharRef (char8[]): No description available. - * @param int64Ref (int64): No description available. - * @param vectorUInt8Ref (uint8[]): No description available. - * @param plgVector4Ref (vec4): No description available. - * @param uint64Ref (uint64): No description available. - * @param vectorptr64Ref (ptr64[]): No description available. - * @param doubleRef (double): No description available. - * @param vectorptr64Ref (ptr64[]): No description available. - * - * @return (callback): mat4x4: No description available. - */ - inline plg::string CallFunc24(Func24 func) { - using CallFunc24Fn = plg::string (*)(Func24); - static CallFunc24Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc24", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc25 - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback Func25 - * @brief No description provided. - * - * @param int32Ref (int32): No description available. - * @param vectorptr64Ref (ptr64[]): No description available. - * @param boolRef (bool): No description available. - * @param uint8Ref (uint8): No description available. - * @param plgStringRef (string): No description available. - * @param plgVector3Ref (vec3): No description available. - * @param int64Ref (int64): No description available. - * @param plgVector4Ref (vec4): No description available. - * @param uint16Ref (uint16): No description available. - * - * @return (callback): double: No description available. - */ - inline plg::string CallFunc25(Func25 func) { - using CallFunc25Fn = plg::string (*)(Func25); - static CallFunc25Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc25", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc26 - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback Func26 - * @brief No description provided. - * - * @param char16Ref (char16): No description available. - * @param plgVector2Ref (vec2): No description available. - * @param plgMatrix4x4Ref (mat4x4): No description available. - * @param vectorFloatRef (float[]): No description available. - * @param int16Ref (int16): No description available. - * @param uint64Ref (uint64): No description available. - * @param uint32Ref (uint32): No description available. - * @param vectorUInt16Ref (uint16[]): No description available. - * @param ptr64Ref (ptr64): No description available. - * @param boolRef (bool): No description available. - * - * @return (callback): char8: No description available. - */ - inline plg::string CallFunc26(Func26 func) { - using CallFunc26Fn = plg::string (*)(Func26); - static CallFunc26Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc26", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc27 - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback Func27 - * @brief No description provided. - * - * @param floatRef (float): No description available. - * @param plgVector3Ref (vec3): No description available. - * @param ptr64Ref (ptr64): No description available. - * @param plgVector2Ref (vec2): No description available. - * @param vectorInt16Ref (int16[]): No description available. - * @param plgMatrix4x4Ref (mat4x4): No description available. - * @param boolRef (bool): No description available. - * @param plgVector4Ref (vec4): No description available. - * @param int8Ref (int8): No description available. - * @param int32Ref (int32): No description available. - * @param vectorUInt8Ref (uint8[]): No description available. - * - * @return (callback): uint8: No description available. - */ - inline plg::string CallFunc27(Func27 func) { - using CallFunc27Fn = plg::string (*)(Func27); - static CallFunc27Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc27", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc28 - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback Func28 - * @brief No description provided. - * - * @param ptr64Ref (ptr64): No description available. - * @param uint16Ref (uint16): No description available. - * @param vectorUInt32Ref (uint32[]): No description available. - * @param plgMatrix4x4Ref (mat4x4): No description available. - * @param floatRef (float): No description available. - * @param plgVector4Ref (vec4): No description available. - * @param plgStringRef (string): No description available. - * @param vectorUInt64Ref (uint64[]): No description available. - * @param int64Ref (int64): No description available. - * @param boolRef (bool): No description available. - * @param plgVector3Ref (vec3): No description available. - * @param vectorFloatRef (float[]): No description available. - * - * @return (callback): string: No description available. - */ - inline plg::string CallFunc28(Func28 func) { - using CallFunc28Fn = plg::string (*)(Func28); - static CallFunc28Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc28", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc29 - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback Func29 - * @brief No description provided. - * - * @param plgVector4Ref (vec4): No description available. - * @param int32Ref (int32): No description available. - * @param vectorInt8Ref (int8[]): No description available. - * @param doubleRef (double): No description available. - * @param boolRef (bool): No description available. - * @param int8Ref (int8): No description available. - * @param vectorUInt16Ref (uint16[]): No description available. - * @param floatRef (float): No description available. - * @param plgStringRef (string): No description available. - * @param plgMatrix4x4Ref (mat4x4): No description available. - * @param uint64Ref (uint64): No description available. - * @param plgVector3Ref (vec3): No description available. - * @param vectorInt64Ref (int64[]): No description available. - * - * @return (callback): string[]: No description available. - */ - inline plg::string CallFunc29(Func29 func) { - using CallFunc29Fn = plg::string (*)(Func29); - static CallFunc29Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc29", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc30 - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback Func30 - * @brief No description provided. - * - * @param ptr64Ref (ptr64): No description available. - * @param plgVector4Ref (vec4): No description available. - * @param int64Ref (int64): No description available. - * @param vectorUInt32Ref (uint32[]): No description available. - * @param boolRef (bool): No description available. - * @param plgStringRef (string): No description available. - * @param plgVector3Ref (vec3): No description available. - * @param vectorUInt8Ref (uint8[]): No description available. - * @param floatRef (float): No description available. - * @param plgVector2Ref (vec2): No description available. - * @param plgMatrix4x4Ref (mat4x4): No description available. - * @param int8Ref (int8): No description available. - * @param vectorFloatRef (float[]): No description available. - * @param doubleRef (double): No description available. - * - * @return (callback): int32: No description available. - */ - inline plg::string CallFunc30(Func30 func) { - using CallFunc30Fn = plg::string (*)(Func30); - static CallFunc30Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc30", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc31 - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback Func31 - * @brief No description provided. - * - * @param charRef (char8): No description available. - * @param uint32Ref (uint32): No description available. - * @param vectorUInt64Ref (uint64[]): No description available. - * @param plgVector4Ref (vec4): No description available. - * @param plgStringRef (string): No description available. - * @param boolRef (bool): No description available. - * @param int64Ref (int64): No description available. - * @param vec2Ref (vec2): No description available. - * @param int8Ref (int8): No description available. - * @param uint16Ref (uint16): No description available. - * @param vectorInt16Ref (int16[]): No description available. - * @param mat4x4Ref (mat4x4): No description available. - * @param vec3Ref (vec3): No description available. - * @param floatRef (float): No description available. - * @param vectorDoubleRef (double[]): No description available. - * - * @return (callback): vec3: No description available. - */ - inline plg::string CallFunc31(Func31 func) { - using CallFunc31Fn = plg::string (*)(Func31); - static CallFunc31Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc31", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc32 - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback Func32 - * @brief No description provided. - * - * @param p1 (int32): No description available. - * @param p2 (uint16): No description available. - * @param p3 (int8[]): No description available. - * @param p4 (vec4): No description available. - * @param p5 (ptr64): No description available. - * @param p6 (uint32[]): No description available. - * @param p7 (mat4x4): No description available. - * @param p8 (uint64): No description available. - * @param p9 (string): No description available. - * @param p10 (int64): No description available. - * @param p11 (vec2): No description available. - * @param p12 (int8[]): No description available. - * @param p13 (bool): No description available. - * @param p14 (vec3): No description available. - * @param p14 (uint8): No description available. - * @param p15 (char16[]): No description available. - * - * @return (callback): double: No description available. - */ - inline plg::string CallFunc32(Func32 func) { - using CallFunc32Fn = plg::string (*)(Func32); - static CallFunc32Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc32", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFunc33 - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback Func33 - * @brief No description provided. - * - * @param variant (any): No description available. - * - * @return (callback): void: No description available. - */ - inline plg::string CallFunc33(Func33 func) { - using CallFunc33Fn = plg::string (*)(Func33); - static CallFunc33Fn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFunc33", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function CallFuncEnum - * @param func (function): No description available. - * - * @return string: No description available. - * - * @callback FuncEnum - * @brief No description provided. - * - * @param p1 (int32): No description available. - * @param p2 (int32[]): No description available. - * - * @return (callback): int32[]: No description available. - */ - inline plg::string CallFuncEnum(FuncEnum func) { - using CallFuncEnumFn = plg::string (*)(FuncEnum); - static CallFuncEnumFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.CallFuncEnum", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @brief No description provided. - * - * @function ReverseCall - * @param test (string): No description available. - */ - inline void ReverseCall(const plg::string &test) { - using ReverseCallFn = void (*)(const plg::string &); - static ReverseCallFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_worker.ReverseCall", reinterpret_cast(&__func)); - __func(test); - } -} // namespace cross_call_worker diff --git a/test/cross_call_master/plugin.cpp b/test/cross_call_master/plugin.cpp index 49f1431..1572496 100644 --- a/test/cross_call_master/plugin.cpp +++ b/test/cross_call_master/plugin.cpp @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include diff --git a/test/cross_call_worker/CMakeLists.txt b/test/cross_call_worker/CMakeLists.txt index 0f8cc59..e8c1993 100644 --- a/test/cross_call_worker/CMakeLists.txt +++ b/test/cross_call_worker/CMakeLists.txt @@ -30,7 +30,7 @@ include(CompatFormat) # # Plugin # -set(PLUGIN_SOURCES "plugin.cpp") +set(PLUGIN_SOURCES "plugin.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/external/plugify/include/cross_call_master/cross_call_master.cpp") add_library(${PROJECT_NAME} SHARED ${PLUGIN_SOURCES}) target_include_directories(${PROJECT_NAME} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/external/plugify/include") diff --git a/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master.cpp b/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master.cpp new file mode 100644 index 0000000..e8b02a9 --- /dev/null +++ b/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master.cpp @@ -0,0 +1,340 @@ +#include "cross_call_master.hpp" + +cross_call_master::_ReverseReturn __cross_call_master_ReverseReturn = nullptr; + +cross_call_master::_NoParamReturnVoidCallback __cross_call_master_NoParamReturnVoidCallback = nullptr; + +cross_call_master::_NoParamReturnBoolCallback __cross_call_master_NoParamReturnBoolCallback = nullptr; + +cross_call_master::_NoParamReturnChar8Callback __cross_call_master_NoParamReturnChar8Callback = nullptr; + +cross_call_master::_NoParamReturnChar16Callback __cross_call_master_NoParamReturnChar16Callback = nullptr; + +cross_call_master::_NoParamReturnInt8Callback __cross_call_master_NoParamReturnInt8Callback = nullptr; + +cross_call_master::_NoParamReturnInt16Callback __cross_call_master_NoParamReturnInt16Callback = nullptr; + +cross_call_master::_NoParamReturnInt32Callback __cross_call_master_NoParamReturnInt32Callback = nullptr; + +cross_call_master::_NoParamReturnInt64Callback __cross_call_master_NoParamReturnInt64Callback = nullptr; + +cross_call_master::_NoParamReturnUInt8Callback __cross_call_master_NoParamReturnUInt8Callback = nullptr; + +cross_call_master::_NoParamReturnUInt16Callback __cross_call_master_NoParamReturnUInt16Callback = nullptr; + +cross_call_master::_NoParamReturnUInt32Callback __cross_call_master_NoParamReturnUInt32Callback = nullptr; + +cross_call_master::_NoParamReturnUInt64Callback __cross_call_master_NoParamReturnUInt64Callback = nullptr; + +cross_call_master::_NoParamReturnPointerCallback __cross_call_master_NoParamReturnPointerCallback = nullptr; + +cross_call_master::_NoParamReturnFloatCallback __cross_call_master_NoParamReturnFloatCallback = nullptr; + +cross_call_master::_NoParamReturnDoubleCallback __cross_call_master_NoParamReturnDoubleCallback = nullptr; + +cross_call_master::_NoParamReturnFunctionCallback __cross_call_master_NoParamReturnFunctionCallback = nullptr; + +cross_call_master::_NoParamReturnStringCallback __cross_call_master_NoParamReturnStringCallback = nullptr; + +cross_call_master::_NoParamReturnAnyCallback __cross_call_master_NoParamReturnAnyCallback = nullptr; + +cross_call_master::_NoParamReturnArrayBoolCallback __cross_call_master_NoParamReturnArrayBoolCallback = nullptr; + +cross_call_master::_NoParamReturnArrayChar8Callback __cross_call_master_NoParamReturnArrayChar8Callback = nullptr; + +cross_call_master::_NoParamReturnArrayChar16Callback __cross_call_master_NoParamReturnArrayChar16Callback = nullptr; + +cross_call_master::_NoParamReturnArrayInt8Callback __cross_call_master_NoParamReturnArrayInt8Callback = nullptr; + +cross_call_master::_NoParamReturnArrayInt16Callback __cross_call_master_NoParamReturnArrayInt16Callback = nullptr; + +cross_call_master::_NoParamReturnArrayInt32Callback __cross_call_master_NoParamReturnArrayInt32Callback = nullptr; + +cross_call_master::_NoParamReturnArrayInt64Callback __cross_call_master_NoParamReturnArrayInt64Callback = nullptr; + +cross_call_master::_NoParamReturnArrayUInt8Callback __cross_call_master_NoParamReturnArrayUInt8Callback = nullptr; + +cross_call_master::_NoParamReturnArrayUInt16Callback __cross_call_master_NoParamReturnArrayUInt16Callback = nullptr; + +cross_call_master::_NoParamReturnArrayUInt32Callback __cross_call_master_NoParamReturnArrayUInt32Callback = nullptr; + +cross_call_master::_NoParamReturnArrayUInt64Callback __cross_call_master_NoParamReturnArrayUInt64Callback = nullptr; + +cross_call_master::_NoParamReturnArrayPointerCallback __cross_call_master_NoParamReturnArrayPointerCallback = nullptr; + +cross_call_master::_NoParamReturnArrayFloatCallback __cross_call_master_NoParamReturnArrayFloatCallback = nullptr; + +cross_call_master::_NoParamReturnArrayDoubleCallback __cross_call_master_NoParamReturnArrayDoubleCallback = nullptr; + +cross_call_master::_NoParamReturnArrayStringCallback __cross_call_master_NoParamReturnArrayStringCallback = nullptr; + +cross_call_master::_NoParamReturnArrayAnyCallback __cross_call_master_NoParamReturnArrayAnyCallback = nullptr; + +cross_call_master::_NoParamReturnArrayVector2Callback __cross_call_master_NoParamReturnArrayVector2Callback = nullptr; + +cross_call_master::_NoParamReturnArrayVector3Callback __cross_call_master_NoParamReturnArrayVector3Callback = nullptr; + +cross_call_master::_NoParamReturnArrayVector4Callback __cross_call_master_NoParamReturnArrayVector4Callback = nullptr; + +cross_call_master::_NoParamReturnArrayMatrix4x4Callback __cross_call_master_NoParamReturnArrayMatrix4x4Callback = nullptr; + +cross_call_master::_NoParamReturnVector2Callback __cross_call_master_NoParamReturnVector2Callback = nullptr; + +cross_call_master::_NoParamReturnVector3Callback __cross_call_master_NoParamReturnVector3Callback = nullptr; + +cross_call_master::_NoParamReturnVector4Callback __cross_call_master_NoParamReturnVector4Callback = nullptr; + +cross_call_master::_NoParamReturnMatrix4x4Callback __cross_call_master_NoParamReturnMatrix4x4Callback = nullptr; + +cross_call_master::_Param1Callback __cross_call_master_Param1Callback = nullptr; + +cross_call_master::_Param2Callback __cross_call_master_Param2Callback = nullptr; + +cross_call_master::_Param3Callback __cross_call_master_Param3Callback = nullptr; + +cross_call_master::_Param4Callback __cross_call_master_Param4Callback = nullptr; + +cross_call_master::_Param5Callback __cross_call_master_Param5Callback = nullptr; + +cross_call_master::_Param6Callback __cross_call_master_Param6Callback = nullptr; + +cross_call_master::_Param7Callback __cross_call_master_Param7Callback = nullptr; + +cross_call_master::_Param8Callback __cross_call_master_Param8Callback = nullptr; + +cross_call_master::_Param9Callback __cross_call_master_Param9Callback = nullptr; + +cross_call_master::_Param10Callback __cross_call_master_Param10Callback = nullptr; + +cross_call_master::_ParamRef1Callback __cross_call_master_ParamRef1Callback = nullptr; + +cross_call_master::_ParamRef2Callback __cross_call_master_ParamRef2Callback = nullptr; + +cross_call_master::_ParamRef3Callback __cross_call_master_ParamRef3Callback = nullptr; + +cross_call_master::_ParamRef4Callback __cross_call_master_ParamRef4Callback = nullptr; + +cross_call_master::_ParamRef5Callback __cross_call_master_ParamRef5Callback = nullptr; + +cross_call_master::_ParamRef6Callback __cross_call_master_ParamRef6Callback = nullptr; + +cross_call_master::_ParamRef7Callback __cross_call_master_ParamRef7Callback = nullptr; + +cross_call_master::_ParamRef8Callback __cross_call_master_ParamRef8Callback = nullptr; + +cross_call_master::_ParamRef9Callback __cross_call_master_ParamRef9Callback = nullptr; + +cross_call_master::_ParamRef10Callback __cross_call_master_ParamRef10Callback = nullptr; + +cross_call_master::_ParamRefVectorsCallback __cross_call_master_ParamRefVectorsCallback = nullptr; + +cross_call_master::_ParamAllPrimitivesCallback __cross_call_master_ParamAllPrimitivesCallback = nullptr; + +cross_call_master::_ParamEnumCallback __cross_call_master_ParamEnumCallback = nullptr; + +cross_call_master::_ParamEnumRefCallback __cross_call_master_ParamEnumRefCallback = nullptr; + +cross_call_master::_ParamVariantCallback __cross_call_master_ParamVariantCallback = nullptr; + +cross_call_master::_ParamVariantRefCallback __cross_call_master_ParamVariantRefCallback = nullptr; + +cross_call_master::_CallFuncVoidCallback __cross_call_master_CallFuncVoidCallback = nullptr; + +cross_call_master::_CallFuncBoolCallback __cross_call_master_CallFuncBoolCallback = nullptr; + +cross_call_master::_CallFuncChar8Callback __cross_call_master_CallFuncChar8Callback = nullptr; + +cross_call_master::_CallFuncChar16Callback __cross_call_master_CallFuncChar16Callback = nullptr; + +cross_call_master::_CallFuncInt8Callback __cross_call_master_CallFuncInt8Callback = nullptr; + +cross_call_master::_CallFuncInt16Callback __cross_call_master_CallFuncInt16Callback = nullptr; + +cross_call_master::_CallFuncInt32Callback __cross_call_master_CallFuncInt32Callback = nullptr; + +cross_call_master::_CallFuncInt64Callback __cross_call_master_CallFuncInt64Callback = nullptr; + +cross_call_master::_CallFuncUInt8Callback __cross_call_master_CallFuncUInt8Callback = nullptr; + +cross_call_master::_CallFuncUInt16Callback __cross_call_master_CallFuncUInt16Callback = nullptr; + +cross_call_master::_CallFuncUInt32Callback __cross_call_master_CallFuncUInt32Callback = nullptr; + +cross_call_master::_CallFuncUInt64Callback __cross_call_master_CallFuncUInt64Callback = nullptr; + +cross_call_master::_CallFuncPtrCallback __cross_call_master_CallFuncPtrCallback = nullptr; + +cross_call_master::_CallFuncFloatCallback __cross_call_master_CallFuncFloatCallback = nullptr; + +cross_call_master::_CallFuncDoubleCallback __cross_call_master_CallFuncDoubleCallback = nullptr; + +cross_call_master::_CallFuncStringCallback __cross_call_master_CallFuncStringCallback = nullptr; + +cross_call_master::_CallFuncAnyCallback __cross_call_master_CallFuncAnyCallback = nullptr; + +cross_call_master::_CallFuncFunctionCallback __cross_call_master_CallFuncFunctionCallback = nullptr; + +cross_call_master::_CallFuncBoolVectorCallback __cross_call_master_CallFuncBoolVectorCallback = nullptr; + +cross_call_master::_CallFuncChar8VectorCallback __cross_call_master_CallFuncChar8VectorCallback = nullptr; + +cross_call_master::_CallFuncChar16VectorCallback __cross_call_master_CallFuncChar16VectorCallback = nullptr; + +cross_call_master::_CallFuncInt8VectorCallback __cross_call_master_CallFuncInt8VectorCallback = nullptr; + +cross_call_master::_CallFuncInt16VectorCallback __cross_call_master_CallFuncInt16VectorCallback = nullptr; + +cross_call_master::_CallFuncInt32VectorCallback __cross_call_master_CallFuncInt32VectorCallback = nullptr; + +cross_call_master::_CallFuncInt64VectorCallback __cross_call_master_CallFuncInt64VectorCallback = nullptr; + +cross_call_master::_CallFuncUInt8VectorCallback __cross_call_master_CallFuncUInt8VectorCallback = nullptr; + +cross_call_master::_CallFuncUInt16VectorCallback __cross_call_master_CallFuncUInt16VectorCallback = nullptr; + +cross_call_master::_CallFuncUInt32VectorCallback __cross_call_master_CallFuncUInt32VectorCallback = nullptr; + +cross_call_master::_CallFuncUInt64VectorCallback __cross_call_master_CallFuncUInt64VectorCallback = nullptr; + +cross_call_master::_CallFuncPtrVectorCallback __cross_call_master_CallFuncPtrVectorCallback = nullptr; + +cross_call_master::_CallFuncFloatVectorCallback __cross_call_master_CallFuncFloatVectorCallback = nullptr; + +cross_call_master::_CallFuncDoubleVectorCallback __cross_call_master_CallFuncDoubleVectorCallback = nullptr; + +cross_call_master::_CallFuncStringVectorCallback __cross_call_master_CallFuncStringVectorCallback = nullptr; + +cross_call_master::_CallFuncAnyVectorCallback __cross_call_master_CallFuncAnyVectorCallback = nullptr; + +cross_call_master::_CallFuncVec2VectorCallback __cross_call_master_CallFuncVec2VectorCallback = nullptr; + +cross_call_master::_CallFuncVec3VectorCallback __cross_call_master_CallFuncVec3VectorCallback = nullptr; + +cross_call_master::_CallFuncVec4VectorCallback __cross_call_master_CallFuncVec4VectorCallback = nullptr; + +cross_call_master::_CallFuncMat4x4VectorCallback __cross_call_master_CallFuncMat4x4VectorCallback = nullptr; + +cross_call_master::_CallFuncVec2Callback __cross_call_master_CallFuncVec2Callback = nullptr; + +cross_call_master::_CallFuncVec3Callback __cross_call_master_CallFuncVec3Callback = nullptr; + +cross_call_master::_CallFuncVec4Callback __cross_call_master_CallFuncVec4Callback = nullptr; + +cross_call_master::_CallFuncMat4x4Callback __cross_call_master_CallFuncMat4x4Callback = nullptr; + +cross_call_master::_CallFunc1Callback __cross_call_master_CallFunc1Callback = nullptr; + +cross_call_master::_CallFunc2Callback __cross_call_master_CallFunc2Callback = nullptr; + +cross_call_master::_CallFunc3Callback __cross_call_master_CallFunc3Callback = nullptr; + +cross_call_master::_CallFunc4Callback __cross_call_master_CallFunc4Callback = nullptr; + +cross_call_master::_CallFunc5Callback __cross_call_master_CallFunc5Callback = nullptr; + +cross_call_master::_CallFunc6Callback __cross_call_master_CallFunc6Callback = nullptr; + +cross_call_master::_CallFunc7Callback __cross_call_master_CallFunc7Callback = nullptr; + +cross_call_master::_CallFunc8Callback __cross_call_master_CallFunc8Callback = nullptr; + +cross_call_master::_CallFunc9Callback __cross_call_master_CallFunc9Callback = nullptr; + +cross_call_master::_CallFunc10Callback __cross_call_master_CallFunc10Callback = nullptr; + +cross_call_master::_CallFunc11Callback __cross_call_master_CallFunc11Callback = nullptr; + +cross_call_master::_CallFunc12Callback __cross_call_master_CallFunc12Callback = nullptr; + +cross_call_master::_CallFunc13Callback __cross_call_master_CallFunc13Callback = nullptr; + +cross_call_master::_CallFunc14Callback __cross_call_master_CallFunc14Callback = nullptr; + +cross_call_master::_CallFunc15Callback __cross_call_master_CallFunc15Callback = nullptr; + +cross_call_master::_CallFunc16Callback __cross_call_master_CallFunc16Callback = nullptr; + +cross_call_master::_CallFunc17Callback __cross_call_master_CallFunc17Callback = nullptr; + +cross_call_master::_CallFunc18Callback __cross_call_master_CallFunc18Callback = nullptr; + +cross_call_master::_CallFunc19Callback __cross_call_master_CallFunc19Callback = nullptr; + +cross_call_master::_CallFunc20Callback __cross_call_master_CallFunc20Callback = nullptr; + +cross_call_master::_CallFunc21Callback __cross_call_master_CallFunc21Callback = nullptr; + +cross_call_master::_CallFunc22Callback __cross_call_master_CallFunc22Callback = nullptr; + +cross_call_master::_CallFunc23Callback __cross_call_master_CallFunc23Callback = nullptr; + +cross_call_master::_CallFunc24Callback __cross_call_master_CallFunc24Callback = nullptr; + +cross_call_master::_CallFunc25Callback __cross_call_master_CallFunc25Callback = nullptr; + +cross_call_master::_CallFunc26Callback __cross_call_master_CallFunc26Callback = nullptr; + +cross_call_master::_CallFunc27Callback __cross_call_master_CallFunc27Callback = nullptr; + +cross_call_master::_CallFunc28Callback __cross_call_master_CallFunc28Callback = nullptr; + +cross_call_master::_CallFunc29Callback __cross_call_master_CallFunc29Callback = nullptr; + +cross_call_master::_CallFunc30Callback __cross_call_master_CallFunc30Callback = nullptr; + +cross_call_master::_CallFunc31Callback __cross_call_master_CallFunc31Callback = nullptr; + +cross_call_master::_CallFunc32Callback __cross_call_master_CallFunc32Callback = nullptr; + +cross_call_master::_CallFunc33Callback __cross_call_master_CallFunc33Callback = nullptr; + +cross_call_master::_CallFuncEnumCallback __cross_call_master_CallFuncEnumCallback = nullptr; + +cross_call_master::_ResourceHandleCreate __cross_call_master_ResourceHandleCreate = nullptr; + +cross_call_master::_ResourceHandleCreateDefault __cross_call_master_ResourceHandleCreateDefault = nullptr; + +cross_call_master::_ResourceHandleDestroy __cross_call_master_ResourceHandleDestroy = nullptr; + +cross_call_master::_ResourceHandleGetId __cross_call_master_ResourceHandleGetId = nullptr; + +cross_call_master::_ResourceHandleGetName __cross_call_master_ResourceHandleGetName = nullptr; + +cross_call_master::_ResourceHandleSetName __cross_call_master_ResourceHandleSetName = nullptr; + +cross_call_master::_ResourceHandleIncrementCounter __cross_call_master_ResourceHandleIncrementCounter = nullptr; + +cross_call_master::_ResourceHandleGetCounter __cross_call_master_ResourceHandleGetCounter = nullptr; + +cross_call_master::_ResourceHandleAddData __cross_call_master_ResourceHandleAddData = nullptr; + +cross_call_master::_ResourceHandleGetData __cross_call_master_ResourceHandleGetData = nullptr; + +cross_call_master::_ResourceHandleGetAliveCount __cross_call_master_ResourceHandleGetAliveCount = nullptr; + +cross_call_master::_ResourceHandleGetTotalCreated __cross_call_master_ResourceHandleGetTotalCreated = nullptr; + +cross_call_master::_ResourceHandleGetTotalDestroyed __cross_call_master_ResourceHandleGetTotalDestroyed = nullptr; + +cross_call_master::_CounterCreate __cross_call_master_CounterCreate = nullptr; + +cross_call_master::_CounterCreateZero __cross_call_master_CounterCreateZero = nullptr; + +cross_call_master::_CounterGetValue __cross_call_master_CounterGetValue = nullptr; + +cross_call_master::_CounterSetValue __cross_call_master_CounterSetValue = nullptr; + +cross_call_master::_CounterIncrement __cross_call_master_CounterIncrement = nullptr; + +cross_call_master::_CounterDecrement __cross_call_master_CounterDecrement = nullptr; + +cross_call_master::_CounterAdd __cross_call_master_CounterAdd = nullptr; + +cross_call_master::_CounterReset __cross_call_master_CounterReset = nullptr; + +cross_call_master::_CounterIsPositive __cross_call_master_CounterIsPositive = nullptr; + +cross_call_master::_CounterCompare __cross_call_master_CounterCompare = nullptr; + +cross_call_master::_CounterSum __cross_call_master_CounterSum = nullptr; + diff --git a/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master.hpp b/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master.hpp new file mode 100644 index 0000000..73d850d --- /dev/null +++ b/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master.hpp @@ -0,0 +1,10 @@ +#pragma once + +// Generated from cross_call_master.pplugin +// This header includes all generated components + +#include "cross_call_master/enums.hpp" +#include "cross_call_master/delegates.hpp" +#include "cross_call_master/resource.hpp" +#include "cross_call_master/counter.hpp" +#include "cross_call_master/core.hpp" diff --git a/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/core.hpp b/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/core.hpp new file mode 100644 index 0000000..5aeee49 --- /dev/null +++ b/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/core.hpp @@ -0,0 +1,2086 @@ +#pragma once + +#include + +#include "enums.hpp" +#include "delegates.hpp" +#include "resource.hpp" +#include "counter.hpp" + +// Generated from cross_call_master.pplugin (group: core) + +namespace cross_call_master { + + using _ReverseReturn = void (*)(const plg::string&); +} +extern "C" PLUGIN_API cross_call_master::_ReverseReturn __cross_call_master_ReverseReturn; +namespace cross_call_master { + /** + * @param returnString (string) + */ + inline void ReverseReturn(const plg::string& returnString) { + return __cross_call_master_ReverseReturn(returnString); + } + + using _NoParamReturnVoidCallback = void (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnVoidCallback __cross_call_master_NoParamReturnVoidCallback; +namespace cross_call_master { + /** + */ + inline void NoParamReturnVoidCallback() { + return __cross_call_master_NoParamReturnVoidCallback(); + } + + using _NoParamReturnBoolCallback = bool (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnBoolCallback __cross_call_master_NoParamReturnBoolCallback; +namespace cross_call_master { + /** + * @return bool + */ + inline bool NoParamReturnBoolCallback() { + return __cross_call_master_NoParamReturnBoolCallback(); + } + + using _NoParamReturnChar8Callback = char (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnChar8Callback __cross_call_master_NoParamReturnChar8Callback; +namespace cross_call_master { + /** + * @return char8 + */ + inline char NoParamReturnChar8Callback() { + return __cross_call_master_NoParamReturnChar8Callback(); + } + + using _NoParamReturnChar16Callback = char16_t (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnChar16Callback __cross_call_master_NoParamReturnChar16Callback; +namespace cross_call_master { + /** + * @return char16 + */ + inline char16_t NoParamReturnChar16Callback() { + return __cross_call_master_NoParamReturnChar16Callback(); + } + + using _NoParamReturnInt8Callback = int8_t (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnInt8Callback __cross_call_master_NoParamReturnInt8Callback; +namespace cross_call_master { + /** + * @return int8 + */ + inline int8_t NoParamReturnInt8Callback() { + return __cross_call_master_NoParamReturnInt8Callback(); + } + + using _NoParamReturnInt16Callback = int16_t (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnInt16Callback __cross_call_master_NoParamReturnInt16Callback; +namespace cross_call_master { + /** + * @return int16 + */ + inline int16_t NoParamReturnInt16Callback() { + return __cross_call_master_NoParamReturnInt16Callback(); + } + + using _NoParamReturnInt32Callback = int32_t (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnInt32Callback __cross_call_master_NoParamReturnInt32Callback; +namespace cross_call_master { + /** + * @return int32 + */ + inline int32_t NoParamReturnInt32Callback() { + return __cross_call_master_NoParamReturnInt32Callback(); + } + + using _NoParamReturnInt64Callback = int64_t (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnInt64Callback __cross_call_master_NoParamReturnInt64Callback; +namespace cross_call_master { + /** + * @return int64 + */ + inline int64_t NoParamReturnInt64Callback() { + return __cross_call_master_NoParamReturnInt64Callback(); + } + + using _NoParamReturnUInt8Callback = uint8_t (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnUInt8Callback __cross_call_master_NoParamReturnUInt8Callback; +namespace cross_call_master { + /** + * @return uint8 + */ + inline uint8_t NoParamReturnUInt8Callback() { + return __cross_call_master_NoParamReturnUInt8Callback(); + } + + using _NoParamReturnUInt16Callback = uint16_t (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnUInt16Callback __cross_call_master_NoParamReturnUInt16Callback; +namespace cross_call_master { + /** + * @return uint16 + */ + inline uint16_t NoParamReturnUInt16Callback() { + return __cross_call_master_NoParamReturnUInt16Callback(); + } + + using _NoParamReturnUInt32Callback = uint32_t (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnUInt32Callback __cross_call_master_NoParamReturnUInt32Callback; +namespace cross_call_master { + /** + * @return uint32 + */ + inline uint32_t NoParamReturnUInt32Callback() { + return __cross_call_master_NoParamReturnUInt32Callback(); + } + + using _NoParamReturnUInt64Callback = uint64_t (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnUInt64Callback __cross_call_master_NoParamReturnUInt64Callback; +namespace cross_call_master { + /** + * @return uint64 + */ + inline uint64_t NoParamReturnUInt64Callback() { + return __cross_call_master_NoParamReturnUInt64Callback(); + } + + using _NoParamReturnPointerCallback = void* (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnPointerCallback __cross_call_master_NoParamReturnPointerCallback; +namespace cross_call_master { + /** + * @return ptr64 + */ + inline void* NoParamReturnPointerCallback() { + return __cross_call_master_NoParamReturnPointerCallback(); + } + + using _NoParamReturnFloatCallback = float (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnFloatCallback __cross_call_master_NoParamReturnFloatCallback; +namespace cross_call_master { + /** + * @return float + */ + inline float NoParamReturnFloatCallback() { + return __cross_call_master_NoParamReturnFloatCallback(); + } + + using _NoParamReturnDoubleCallback = double (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnDoubleCallback __cross_call_master_NoParamReturnDoubleCallback; +namespace cross_call_master { + /** + * @return double + */ + inline double NoParamReturnDoubleCallback() { + return __cross_call_master_NoParamReturnDoubleCallback(); + } + + using _NoParamReturnFunctionCallback = NoParamReturnFunctionCallbackFunc (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnFunctionCallback __cross_call_master_NoParamReturnFunctionCallback; +namespace cross_call_master { + /** + * @return function + */ + inline NoParamReturnFunctionCallbackFunc NoParamReturnFunctionCallback() { + return __cross_call_master_NoParamReturnFunctionCallback(); + } + + using _NoParamReturnStringCallback = plg::string (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnStringCallback __cross_call_master_NoParamReturnStringCallback; +namespace cross_call_master { + /** + * @return string + */ + inline plg::string NoParamReturnStringCallback() { + return __cross_call_master_NoParamReturnStringCallback(); + } + + using _NoParamReturnAnyCallback = plg::any (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnAnyCallback __cross_call_master_NoParamReturnAnyCallback; +namespace cross_call_master { + /** + * @return any + */ + inline plg::any NoParamReturnAnyCallback() { + return __cross_call_master_NoParamReturnAnyCallback(); + } + + using _NoParamReturnArrayBoolCallback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayBoolCallback __cross_call_master_NoParamReturnArrayBoolCallback; +namespace cross_call_master { + /** + * @return bool[] + */ + inline plg::vector NoParamReturnArrayBoolCallback() { + return __cross_call_master_NoParamReturnArrayBoolCallback(); + } + + using _NoParamReturnArrayChar8Callback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayChar8Callback __cross_call_master_NoParamReturnArrayChar8Callback; +namespace cross_call_master { + /** + * @return char8[] + */ + inline plg::vector NoParamReturnArrayChar8Callback() { + return __cross_call_master_NoParamReturnArrayChar8Callback(); + } + + using _NoParamReturnArrayChar16Callback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayChar16Callback __cross_call_master_NoParamReturnArrayChar16Callback; +namespace cross_call_master { + /** + * @return char16[] + */ + inline plg::vector NoParamReturnArrayChar16Callback() { + return __cross_call_master_NoParamReturnArrayChar16Callback(); + } + + using _NoParamReturnArrayInt8Callback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayInt8Callback __cross_call_master_NoParamReturnArrayInt8Callback; +namespace cross_call_master { + /** + * @return int8[] + */ + inline plg::vector NoParamReturnArrayInt8Callback() { + return __cross_call_master_NoParamReturnArrayInt8Callback(); + } + + using _NoParamReturnArrayInt16Callback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayInt16Callback __cross_call_master_NoParamReturnArrayInt16Callback; +namespace cross_call_master { + /** + * @return int16[] + */ + inline plg::vector NoParamReturnArrayInt16Callback() { + return __cross_call_master_NoParamReturnArrayInt16Callback(); + } + + using _NoParamReturnArrayInt32Callback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayInt32Callback __cross_call_master_NoParamReturnArrayInt32Callback; +namespace cross_call_master { + /** + * @return int32[] + */ + inline plg::vector NoParamReturnArrayInt32Callback() { + return __cross_call_master_NoParamReturnArrayInt32Callback(); + } + + using _NoParamReturnArrayInt64Callback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayInt64Callback __cross_call_master_NoParamReturnArrayInt64Callback; +namespace cross_call_master { + /** + * @return int64[] + */ + inline plg::vector NoParamReturnArrayInt64Callback() { + return __cross_call_master_NoParamReturnArrayInt64Callback(); + } + + using _NoParamReturnArrayUInt8Callback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayUInt8Callback __cross_call_master_NoParamReturnArrayUInt8Callback; +namespace cross_call_master { + /** + * @return uint8[] + */ + inline plg::vector NoParamReturnArrayUInt8Callback() { + return __cross_call_master_NoParamReturnArrayUInt8Callback(); + } + + using _NoParamReturnArrayUInt16Callback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayUInt16Callback __cross_call_master_NoParamReturnArrayUInt16Callback; +namespace cross_call_master { + /** + * @return uint16[] + */ + inline plg::vector NoParamReturnArrayUInt16Callback() { + return __cross_call_master_NoParamReturnArrayUInt16Callback(); + } + + using _NoParamReturnArrayUInt32Callback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayUInt32Callback __cross_call_master_NoParamReturnArrayUInt32Callback; +namespace cross_call_master { + /** + * @return uint32[] + */ + inline plg::vector NoParamReturnArrayUInt32Callback() { + return __cross_call_master_NoParamReturnArrayUInt32Callback(); + } + + using _NoParamReturnArrayUInt64Callback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayUInt64Callback __cross_call_master_NoParamReturnArrayUInt64Callback; +namespace cross_call_master { + /** + * @return uint64[] + */ + inline plg::vector NoParamReturnArrayUInt64Callback() { + return __cross_call_master_NoParamReturnArrayUInt64Callback(); + } + + using _NoParamReturnArrayPointerCallback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayPointerCallback __cross_call_master_NoParamReturnArrayPointerCallback; +namespace cross_call_master { + /** + * @return ptr64[] + */ + inline plg::vector NoParamReturnArrayPointerCallback() { + return __cross_call_master_NoParamReturnArrayPointerCallback(); + } + + using _NoParamReturnArrayFloatCallback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayFloatCallback __cross_call_master_NoParamReturnArrayFloatCallback; +namespace cross_call_master { + /** + * @return float[] + */ + inline plg::vector NoParamReturnArrayFloatCallback() { + return __cross_call_master_NoParamReturnArrayFloatCallback(); + } + + using _NoParamReturnArrayDoubleCallback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayDoubleCallback __cross_call_master_NoParamReturnArrayDoubleCallback; +namespace cross_call_master { + /** + * @return double[] + */ + inline plg::vector NoParamReturnArrayDoubleCallback() { + return __cross_call_master_NoParamReturnArrayDoubleCallback(); + } + + using _NoParamReturnArrayStringCallback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayStringCallback __cross_call_master_NoParamReturnArrayStringCallback; +namespace cross_call_master { + /** + * @return string[] + */ + inline plg::vector NoParamReturnArrayStringCallback() { + return __cross_call_master_NoParamReturnArrayStringCallback(); + } + + using _NoParamReturnArrayAnyCallback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayAnyCallback __cross_call_master_NoParamReturnArrayAnyCallback; +namespace cross_call_master { + /** + * @return any[] + */ + inline plg::vector NoParamReturnArrayAnyCallback() { + return __cross_call_master_NoParamReturnArrayAnyCallback(); + } + + using _NoParamReturnArrayVector2Callback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayVector2Callback __cross_call_master_NoParamReturnArrayVector2Callback; +namespace cross_call_master { + /** + * @return vec2[] + */ + inline plg::vector NoParamReturnArrayVector2Callback() { + return __cross_call_master_NoParamReturnArrayVector2Callback(); + } + + using _NoParamReturnArrayVector3Callback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayVector3Callback __cross_call_master_NoParamReturnArrayVector3Callback; +namespace cross_call_master { + /** + * @return vec3[] + */ + inline plg::vector NoParamReturnArrayVector3Callback() { + return __cross_call_master_NoParamReturnArrayVector3Callback(); + } + + using _NoParamReturnArrayVector4Callback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayVector4Callback __cross_call_master_NoParamReturnArrayVector4Callback; +namespace cross_call_master { + /** + * @return vec4[] + */ + inline plg::vector NoParamReturnArrayVector4Callback() { + return __cross_call_master_NoParamReturnArrayVector4Callback(); + } + + using _NoParamReturnArrayMatrix4x4Callback = plg::vector (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnArrayMatrix4x4Callback __cross_call_master_NoParamReturnArrayMatrix4x4Callback; +namespace cross_call_master { + /** + * @return mat4x4[] + */ + inline plg::vector NoParamReturnArrayMatrix4x4Callback() { + return __cross_call_master_NoParamReturnArrayMatrix4x4Callback(); + } + + using _NoParamReturnVector2Callback = plg::vec2 (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnVector2Callback __cross_call_master_NoParamReturnVector2Callback; +namespace cross_call_master { + /** + * @return vec2 + */ + inline plg::vec2 NoParamReturnVector2Callback() { + return __cross_call_master_NoParamReturnVector2Callback(); + } + + using _NoParamReturnVector3Callback = plg::vec3 (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnVector3Callback __cross_call_master_NoParamReturnVector3Callback; +namespace cross_call_master { + /** + * @return vec3 + */ + inline plg::vec3 NoParamReturnVector3Callback() { + return __cross_call_master_NoParamReturnVector3Callback(); + } + + using _NoParamReturnVector4Callback = plg::vec4 (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnVector4Callback __cross_call_master_NoParamReturnVector4Callback; +namespace cross_call_master { + /** + * @return vec4 + */ + inline plg::vec4 NoParamReturnVector4Callback() { + return __cross_call_master_NoParamReturnVector4Callback(); + } + + using _NoParamReturnMatrix4x4Callback = plg::mat4x4 (*)(); +} +extern "C" PLUGIN_API cross_call_master::_NoParamReturnMatrix4x4Callback __cross_call_master_NoParamReturnMatrix4x4Callback; +namespace cross_call_master { + /** + * @return mat4x4 + */ + inline plg::mat4x4 NoParamReturnMatrix4x4Callback() { + return __cross_call_master_NoParamReturnMatrix4x4Callback(); + } + + using _Param1Callback = void (*)(int32_t); +} +extern "C" PLUGIN_API cross_call_master::_Param1Callback __cross_call_master_Param1Callback; +namespace cross_call_master { + /** + * @param a (int32) + */ + inline void Param1Callback(int32_t a) { + return __cross_call_master_Param1Callback(a); + } + + using _Param2Callback = void (*)(int32_t, float); +} +extern "C" PLUGIN_API cross_call_master::_Param2Callback __cross_call_master_Param2Callback; +namespace cross_call_master { + /** + * @param a (int32) + * @param b (float) + */ + inline void Param2Callback(int32_t a, float b) { + return __cross_call_master_Param2Callback(a, b); + } + + using _Param3Callback = void (*)(int32_t, float, double); +} +extern "C" PLUGIN_API cross_call_master::_Param3Callback __cross_call_master_Param3Callback; +namespace cross_call_master { + /** + * @param a (int32) + * @param b (float) + * @param c (double) + */ + inline void Param3Callback(int32_t a, float b, double c) { + return __cross_call_master_Param3Callback(a, b, c); + } + + using _Param4Callback = void (*)(int32_t, float, double, const plg::vec4&); +} +extern "C" PLUGIN_API cross_call_master::_Param4Callback __cross_call_master_Param4Callback; +namespace cross_call_master { + /** + * @param a (int32) + * @param b (float) + * @param c (double) + * @param d (vec4) + */ + inline void Param4Callback(int32_t a, float b, double c, const plg::vec4& d) { + return __cross_call_master_Param4Callback(a, b, c, d); + } + + using _Param5Callback = void (*)(int32_t, float, double, const plg::vec4&, const plg::vector&); +} +extern "C" PLUGIN_API cross_call_master::_Param5Callback __cross_call_master_Param5Callback; +namespace cross_call_master { + /** + * @param a (int32) + * @param b (float) + * @param c (double) + * @param d (vec4) + * @param e (int64[]) + */ + inline void Param5Callback(int32_t a, float b, double c, const plg::vec4& d, const plg::vector& e) { + return __cross_call_master_Param5Callback(a, b, c, d, e); + } + + using _Param6Callback = void (*)(int32_t, float, double, const plg::vec4&, const plg::vector&, char); +} +extern "C" PLUGIN_API cross_call_master::_Param6Callback __cross_call_master_Param6Callback; +namespace cross_call_master { + /** + * @param a (int32) + * @param b (float) + * @param c (double) + * @param d (vec4) + * @param e (int64[]) + * @param f (char8) + */ + inline void Param6Callback(int32_t a, float b, double c, const plg::vec4& d, const plg::vector& e, char f) { + return __cross_call_master_Param6Callback(a, b, c, d, e, f); + } + + using _Param7Callback = void (*)(int32_t, float, double, const plg::vec4&, const plg::vector&, char, const plg::string&); +} +extern "C" PLUGIN_API cross_call_master::_Param7Callback __cross_call_master_Param7Callback; +namespace cross_call_master { + /** + * @param a (int32) + * @param b (float) + * @param c (double) + * @param d (vec4) + * @param e (int64[]) + * @param f (char8) + * @param g (string) + */ + inline void Param7Callback(int32_t a, float b, double c, const plg::vec4& d, const plg::vector& e, char f, const plg::string& g) { + return __cross_call_master_Param7Callback(a, b, c, d, e, f, g); + } + + using _Param8Callback = void (*)(int32_t, float, double, const plg::vec4&, const plg::vector&, char, const plg::string&, char16_t); +} +extern "C" PLUGIN_API cross_call_master::_Param8Callback __cross_call_master_Param8Callback; +namespace cross_call_master { + /** + * @param a (int32) + * @param b (float) + * @param c (double) + * @param d (vec4) + * @param e (int64[]) + * @param f (char8) + * @param g (string) + * @param h (char16) + */ + inline void Param8Callback(int32_t a, float b, double c, const plg::vec4& d, const plg::vector& e, char f, const plg::string& g, char16_t h) { + return __cross_call_master_Param8Callback(a, b, c, d, e, f, g, h); + } + + using _Param9Callback = void (*)(int32_t, float, double, const plg::vec4&, const plg::vector&, char, const plg::string&, char16_t, int16_t); +} +extern "C" PLUGIN_API cross_call_master::_Param9Callback __cross_call_master_Param9Callback; +namespace cross_call_master { + /** + * @param a (int32) + * @param b (float) + * @param c (double) + * @param d (vec4) + * @param e (int64[]) + * @param f (char8) + * @param g (string) + * @param h (char16) + * @param k (int16) + */ + inline void Param9Callback(int32_t a, float b, double c, const plg::vec4& d, const plg::vector& e, char f, const plg::string& g, char16_t h, int16_t k) { + return __cross_call_master_Param9Callback(a, b, c, d, e, f, g, h, k); + } + + using _Param10Callback = void (*)(int32_t, float, double, const plg::vec4&, const plg::vector&, char, const plg::string&, char16_t, int16_t, void*); +} +extern "C" PLUGIN_API cross_call_master::_Param10Callback __cross_call_master_Param10Callback; +namespace cross_call_master { + /** + * @param a (int32) + * @param b (float) + * @param c (double) + * @param d (vec4) + * @param e (int64[]) + * @param f (char8) + * @param g (string) + * @param h (char16) + * @param k (int16) + * @param l (ptr64) + */ + inline void Param10Callback(int32_t a, float b, double c, const plg::vec4& d, const plg::vector& e, char f, const plg::string& g, char16_t h, int16_t k, void* l) { + return __cross_call_master_Param10Callback(a, b, c, d, e, f, g, h, k, l); + } + + using _ParamRef1Callback = void (*)(int32_t&); +} +extern "C" PLUGIN_API cross_call_master::_ParamRef1Callback __cross_call_master_ParamRef1Callback; +namespace cross_call_master { + /** + * @param a (int32&) + */ + inline void ParamRef1Callback(int32_t& a) { + return __cross_call_master_ParamRef1Callback(a); + } + + using _ParamRef2Callback = void (*)(int32_t&, float&); +} +extern "C" PLUGIN_API cross_call_master::_ParamRef2Callback __cross_call_master_ParamRef2Callback; +namespace cross_call_master { + /** + * @param a (int32&) + * @param b (float&) + */ + inline void ParamRef2Callback(int32_t& a, float& b) { + return __cross_call_master_ParamRef2Callback(a, b); + } + + using _ParamRef3Callback = void (*)(int32_t&, float&, double&); +} +extern "C" PLUGIN_API cross_call_master::_ParamRef3Callback __cross_call_master_ParamRef3Callback; +namespace cross_call_master { + /** + * @param a (int32&) + * @param b (float&) + * @param c (double&) + */ + inline void ParamRef3Callback(int32_t& a, float& b, double& c) { + return __cross_call_master_ParamRef3Callback(a, b, c); + } + + using _ParamRef4Callback = void (*)(int32_t&, float&, double&, plg::vec4&); +} +extern "C" PLUGIN_API cross_call_master::_ParamRef4Callback __cross_call_master_ParamRef4Callback; +namespace cross_call_master { + /** + * @param a (int32&) + * @param b (float&) + * @param c (double&) + * @param d (vec4&) + */ + inline void ParamRef4Callback(int32_t& a, float& b, double& c, plg::vec4& d) { + return __cross_call_master_ParamRef4Callback(a, b, c, d); + } + + using _ParamRef5Callback = void (*)(int32_t&, float&, double&, plg::vec4&, plg::vector&); +} +extern "C" PLUGIN_API cross_call_master::_ParamRef5Callback __cross_call_master_ParamRef5Callback; +namespace cross_call_master { + /** + * @param a (int32&) + * @param b (float&) + * @param c (double&) + * @param d (vec4&) + * @param e (int64[]&) + */ + inline void ParamRef5Callback(int32_t& a, float& b, double& c, plg::vec4& d, plg::vector& e) { + return __cross_call_master_ParamRef5Callback(a, b, c, d, e); + } + + using _ParamRef6Callback = void (*)(int32_t&, float&, double&, plg::vec4&, plg::vector&, char&); +} +extern "C" PLUGIN_API cross_call_master::_ParamRef6Callback __cross_call_master_ParamRef6Callback; +namespace cross_call_master { + /** + * @param a (int32&) + * @param b (float&) + * @param c (double&) + * @param d (vec4&) + * @param e (int64[]&) + * @param f (char8&) + */ + inline void ParamRef6Callback(int32_t& a, float& b, double& c, plg::vec4& d, plg::vector& e, char& f) { + return __cross_call_master_ParamRef6Callback(a, b, c, d, e, f); + } + + using _ParamRef7Callback = void (*)(int32_t&, float&, double&, plg::vec4&, plg::vector&, char&, plg::string&); +} +extern "C" PLUGIN_API cross_call_master::_ParamRef7Callback __cross_call_master_ParamRef7Callback; +namespace cross_call_master { + /** + * @param a (int32&) + * @param b (float&) + * @param c (double&) + * @param d (vec4&) + * @param e (int64[]&) + * @param f (char8&) + * @param g (string&) + */ + inline void ParamRef7Callback(int32_t& a, float& b, double& c, plg::vec4& d, plg::vector& e, char& f, plg::string& g) { + return __cross_call_master_ParamRef7Callback(a, b, c, d, e, f, g); + } + + using _ParamRef8Callback = void (*)(int32_t&, float&, double&, plg::vec4&, plg::vector&, char&, plg::string&, char16_t&); +} +extern "C" PLUGIN_API cross_call_master::_ParamRef8Callback __cross_call_master_ParamRef8Callback; +namespace cross_call_master { + /** + * @param a (int32&) + * @param b (float&) + * @param c (double&) + * @param d (vec4&) + * @param e (int64[]&) + * @param f (char8&) + * @param g (string&) + * @param h (char16&) + */ + inline void ParamRef8Callback(int32_t& a, float& b, double& c, plg::vec4& d, plg::vector& e, char& f, plg::string& g, char16_t& h) { + return __cross_call_master_ParamRef8Callback(a, b, c, d, e, f, g, h); + } + + using _ParamRef9Callback = void (*)(int32_t&, float&, double&, plg::vec4&, plg::vector&, char&, plg::string&, char16_t&, int16_t&); +} +extern "C" PLUGIN_API cross_call_master::_ParamRef9Callback __cross_call_master_ParamRef9Callback; +namespace cross_call_master { + /** + * @param a (int32&) + * @param b (float&) + * @param c (double&) + * @param d (vec4&) + * @param e (int64[]&) + * @param f (char8&) + * @param g (string&) + * @param h (char16&) + * @param k (int16&) + */ + inline void ParamRef9Callback(int32_t& a, float& b, double& c, plg::vec4& d, plg::vector& e, char& f, plg::string& g, char16_t& h, int16_t& k) { + return __cross_call_master_ParamRef9Callback(a, b, c, d, e, f, g, h, k); + } + + using _ParamRef10Callback = void (*)(int32_t&, float&, double&, plg::vec4&, plg::vector&, char&, plg::string&, char16_t&, int16_t&, void*&); +} +extern "C" PLUGIN_API cross_call_master::_ParamRef10Callback __cross_call_master_ParamRef10Callback; +namespace cross_call_master { + /** + * @param a (int32&) + * @param b (float&) + * @param c (double&) + * @param d (vec4&) + * @param e (int64[]&) + * @param f (char8&) + * @param g (string&) + * @param h (char16&) + * @param k (int16&) + * @param l (ptr64&) + */ + inline void ParamRef10Callback(int32_t& a, float& b, double& c, plg::vec4& d, plg::vector& e, char& f, plg::string& g, char16_t& h, int16_t& k, void*& l) { + return __cross_call_master_ParamRef10Callback(a, b, c, d, e, f, g, h, k, l); + } + + using _ParamRefVectorsCallback = void (*)(plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&); +} +extern "C" PLUGIN_API cross_call_master::_ParamRefVectorsCallback __cross_call_master_ParamRefVectorsCallback; +namespace cross_call_master { + /** + * @param p1 (bool[]&) + * @param p2 (char8[]&) + * @param p3 (char16[]&) + * @param p4 (int8[]&) + * @param p5 (int16[]&) + * @param p6 (int32[]&) + * @param p7 (int64[]&) + * @param p8 (uint8[]&) + * @param p9 (uint16[]&) + * @param p10 (uint32[]&) + * @param p11 (uint64[]&) + * @param p12 (ptr64[]&) + * @param p13 (float[]&) + * @param p14 (double[]&) + * @param p15 (string[]&) + */ + inline void ParamRefVectorsCallback(plg::vector& p1, plg::vector& p2, plg::vector& p3, plg::vector& p4, plg::vector& p5, plg::vector& p6, plg::vector& p7, plg::vector& p8, plg::vector& p9, plg::vector& p10, plg::vector& p11, plg::vector& p12, plg::vector& p13, plg::vector& p14, plg::vector& p15) { + return __cross_call_master_ParamRefVectorsCallback(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); + } + + using _ParamAllPrimitivesCallback = int64_t (*)(bool, char, char16_t, int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t, uint32_t, uint64_t, void*, float, double); +} +extern "C" PLUGIN_API cross_call_master::_ParamAllPrimitivesCallback __cross_call_master_ParamAllPrimitivesCallback; +namespace cross_call_master { + /** + * @param p1 (bool) + * @param p2 (char8) + * @param p3 (char16) + * @param p4 (int8) + * @param p5 (int16) + * @param p6 (int32) + * @param p7 (int64) + * @param p8 (uint8) + * @param p9 (uint16) + * @param p10 (uint32) + * @param p11 (uint64) + * @param p12 (ptr64) + * @param p13 (float) + * @param p14 (double) + * @return int64 + */ + inline int64_t ParamAllPrimitivesCallback(bool p1, char p2, char16_t p3, int8_t p4, int16_t p5, int32_t p6, int64_t p7, uint8_t p8, uint16_t p9, uint32_t p10, uint64_t p11, void* p12, float p13, double p14) { + return __cross_call_master_ParamAllPrimitivesCallback(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); + } + + using _ParamEnumCallback = int32_t (*)(Example, const plg::vector&); +} +extern "C" PLUGIN_API cross_call_master::_ParamEnumCallback __cross_call_master_ParamEnumCallback; +namespace cross_call_master { + /** + * @param p1 (int32) + * @param p2 (int32[]) + * @return int32 + */ + inline int32_t ParamEnumCallback(Example p1, const plg::vector& p2) { + return __cross_call_master_ParamEnumCallback(p1, p2); + } + + using _ParamEnumRefCallback = int32_t (*)(Example&, plg::vector&); +} +extern "C" PLUGIN_API cross_call_master::_ParamEnumRefCallback __cross_call_master_ParamEnumRefCallback; +namespace cross_call_master { + /** + * @param p1 (int32&) + * @param p2 (int32[]&) + * @return int32 + */ + inline int32_t ParamEnumRefCallback(Example& p1, plg::vector& p2) { + return __cross_call_master_ParamEnumRefCallback(p1, p2); + } + + using _ParamVariantCallback = void (*)(const plg::any&, const plg::vector&); +} +extern "C" PLUGIN_API cross_call_master::_ParamVariantCallback __cross_call_master_ParamVariantCallback; +namespace cross_call_master { + /** + * @param p1 (any) + * @param p2 (any[]) + */ + inline void ParamVariantCallback(const plg::any& p1, const plg::vector& p2) { + return __cross_call_master_ParamVariantCallback(p1, p2); + } + + using _ParamVariantRefCallback = void (*)(plg::any&, plg::vector&); +} +extern "C" PLUGIN_API cross_call_master::_ParamVariantRefCallback __cross_call_master_ParamVariantRefCallback; +namespace cross_call_master { + /** + * @param p1 (any&) + * @param p2 (any[]&) + */ + inline void ParamVariantRefCallback(plg::any& p1, plg::vector& p2) { + return __cross_call_master_ParamVariantRefCallback(p1, p2); + } + + using _CallFuncVoidCallback = void (*)(FuncVoid); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncVoidCallback __cross_call_master_CallFuncVoidCallback; +namespace cross_call_master { + /** + * @param func (function) + */ + inline void CallFuncVoidCallback(FuncVoid func) { + return __cross_call_master_CallFuncVoidCallback(func); + } + + using _CallFuncBoolCallback = bool (*)(FuncBool); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncBoolCallback __cross_call_master_CallFuncBoolCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return bool + */ + inline bool CallFuncBoolCallback(FuncBool func) { + return __cross_call_master_CallFuncBoolCallback(func); + } + + using _CallFuncChar8Callback = char (*)(FuncChar8); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncChar8Callback __cross_call_master_CallFuncChar8Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return char8 + */ + inline char CallFuncChar8Callback(FuncChar8 func) { + return __cross_call_master_CallFuncChar8Callback(func); + } + + using _CallFuncChar16Callback = char16_t (*)(FuncChar16); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncChar16Callback __cross_call_master_CallFuncChar16Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return char16 + */ + inline char16_t CallFuncChar16Callback(FuncChar16 func) { + return __cross_call_master_CallFuncChar16Callback(func); + } + + using _CallFuncInt8Callback = int8_t (*)(FuncInt8); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncInt8Callback __cross_call_master_CallFuncInt8Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return int8 + */ + inline int8_t CallFuncInt8Callback(FuncInt8 func) { + return __cross_call_master_CallFuncInt8Callback(func); + } + + using _CallFuncInt16Callback = int16_t (*)(FuncInt16); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncInt16Callback __cross_call_master_CallFuncInt16Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return int16 + */ + inline int16_t CallFuncInt16Callback(FuncInt16 func) { + return __cross_call_master_CallFuncInt16Callback(func); + } + + using _CallFuncInt32Callback = int32_t (*)(FuncInt32); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncInt32Callback __cross_call_master_CallFuncInt32Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return int32 + */ + inline int32_t CallFuncInt32Callback(FuncInt32 func) { + return __cross_call_master_CallFuncInt32Callback(func); + } + + using _CallFuncInt64Callback = int64_t (*)(FuncInt64); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncInt64Callback __cross_call_master_CallFuncInt64Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return int64 + */ + inline int64_t CallFuncInt64Callback(FuncInt64 func) { + return __cross_call_master_CallFuncInt64Callback(func); + } + + using _CallFuncUInt8Callback = uint8_t (*)(FuncUInt8); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncUInt8Callback __cross_call_master_CallFuncUInt8Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return uint8 + */ + inline uint8_t CallFuncUInt8Callback(FuncUInt8 func) { + return __cross_call_master_CallFuncUInt8Callback(func); + } + + using _CallFuncUInt16Callback = uint16_t (*)(FuncUInt16); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncUInt16Callback __cross_call_master_CallFuncUInt16Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return uint16 + */ + inline uint16_t CallFuncUInt16Callback(FuncUInt16 func) { + return __cross_call_master_CallFuncUInt16Callback(func); + } + + using _CallFuncUInt32Callback = uint32_t (*)(FuncUInt32); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncUInt32Callback __cross_call_master_CallFuncUInt32Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return uint32 + */ + inline uint32_t CallFuncUInt32Callback(FuncUInt32 func) { + return __cross_call_master_CallFuncUInt32Callback(func); + } + + using _CallFuncUInt64Callback = uint64_t (*)(FuncUInt64); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncUInt64Callback __cross_call_master_CallFuncUInt64Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return uint64 + */ + inline uint64_t CallFuncUInt64Callback(FuncUInt64 func) { + return __cross_call_master_CallFuncUInt64Callback(func); + } + + using _CallFuncPtrCallback = void* (*)(FuncPtr); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncPtrCallback __cross_call_master_CallFuncPtrCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return ptr64 + */ + inline void* CallFuncPtrCallback(FuncPtr func) { + return __cross_call_master_CallFuncPtrCallback(func); + } + + using _CallFuncFloatCallback = float (*)(FuncFloat); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncFloatCallback __cross_call_master_CallFuncFloatCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return float + */ + inline float CallFuncFloatCallback(FuncFloat func) { + return __cross_call_master_CallFuncFloatCallback(func); + } + + using _CallFuncDoubleCallback = double (*)(FuncDouble); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncDoubleCallback __cross_call_master_CallFuncDoubleCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return double + */ + inline double CallFuncDoubleCallback(FuncDouble func) { + return __cross_call_master_CallFuncDoubleCallback(func); + } + + using _CallFuncStringCallback = plg::string (*)(FuncString); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncStringCallback __cross_call_master_CallFuncStringCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFuncStringCallback(FuncString func) { + return __cross_call_master_CallFuncStringCallback(func); + } + + using _CallFuncAnyCallback = plg::any (*)(FuncAny); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncAnyCallback __cross_call_master_CallFuncAnyCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return any + */ + inline plg::any CallFuncAnyCallback(FuncAny func) { + return __cross_call_master_CallFuncAnyCallback(func); + } + + using _CallFuncFunctionCallback = void* (*)(FuncFunction); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncFunctionCallback __cross_call_master_CallFuncFunctionCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return ptr64 + */ + inline void* CallFuncFunctionCallback(FuncFunction func) { + return __cross_call_master_CallFuncFunctionCallback(func); + } + + using _CallFuncBoolVectorCallback = plg::vector (*)(FuncBoolVector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncBoolVectorCallback __cross_call_master_CallFuncBoolVectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return bool[] + */ + inline plg::vector CallFuncBoolVectorCallback(FuncBoolVector func) { + return __cross_call_master_CallFuncBoolVectorCallback(func); + } + + using _CallFuncChar8VectorCallback = plg::vector (*)(FuncChar8Vector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncChar8VectorCallback __cross_call_master_CallFuncChar8VectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return char8[] + */ + inline plg::vector CallFuncChar8VectorCallback(FuncChar8Vector func) { + return __cross_call_master_CallFuncChar8VectorCallback(func); + } + + using _CallFuncChar16VectorCallback = plg::vector (*)(FuncChar16Vector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncChar16VectorCallback __cross_call_master_CallFuncChar16VectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return char16[] + */ + inline plg::vector CallFuncChar16VectorCallback(FuncChar16Vector func) { + return __cross_call_master_CallFuncChar16VectorCallback(func); + } + + using _CallFuncInt8VectorCallback = plg::vector (*)(FuncInt8Vector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncInt8VectorCallback __cross_call_master_CallFuncInt8VectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return int8[] + */ + inline plg::vector CallFuncInt8VectorCallback(FuncInt8Vector func) { + return __cross_call_master_CallFuncInt8VectorCallback(func); + } + + using _CallFuncInt16VectorCallback = plg::vector (*)(FuncInt16Vector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncInt16VectorCallback __cross_call_master_CallFuncInt16VectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return int16[] + */ + inline plg::vector CallFuncInt16VectorCallback(FuncInt16Vector func) { + return __cross_call_master_CallFuncInt16VectorCallback(func); + } + + using _CallFuncInt32VectorCallback = plg::vector (*)(FuncInt32Vector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncInt32VectorCallback __cross_call_master_CallFuncInt32VectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return int32[] + */ + inline plg::vector CallFuncInt32VectorCallback(FuncInt32Vector func) { + return __cross_call_master_CallFuncInt32VectorCallback(func); + } + + using _CallFuncInt64VectorCallback = plg::vector (*)(FuncInt64Vector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncInt64VectorCallback __cross_call_master_CallFuncInt64VectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return int64[] + */ + inline plg::vector CallFuncInt64VectorCallback(FuncInt64Vector func) { + return __cross_call_master_CallFuncInt64VectorCallback(func); + } + + using _CallFuncUInt8VectorCallback = plg::vector (*)(FuncUInt8Vector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncUInt8VectorCallback __cross_call_master_CallFuncUInt8VectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return uint8[] + */ + inline plg::vector CallFuncUInt8VectorCallback(FuncUInt8Vector func) { + return __cross_call_master_CallFuncUInt8VectorCallback(func); + } + + using _CallFuncUInt16VectorCallback = plg::vector (*)(FuncUInt16Vector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncUInt16VectorCallback __cross_call_master_CallFuncUInt16VectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return uint16[] + */ + inline plg::vector CallFuncUInt16VectorCallback(FuncUInt16Vector func) { + return __cross_call_master_CallFuncUInt16VectorCallback(func); + } + + using _CallFuncUInt32VectorCallback = plg::vector (*)(FuncUInt32Vector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncUInt32VectorCallback __cross_call_master_CallFuncUInt32VectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return uint32[] + */ + inline plg::vector CallFuncUInt32VectorCallback(FuncUInt32Vector func) { + return __cross_call_master_CallFuncUInt32VectorCallback(func); + } + + using _CallFuncUInt64VectorCallback = plg::vector (*)(FuncUInt64Vector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncUInt64VectorCallback __cross_call_master_CallFuncUInt64VectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return uint64[] + */ + inline plg::vector CallFuncUInt64VectorCallback(FuncUInt64Vector func) { + return __cross_call_master_CallFuncUInt64VectorCallback(func); + } + + using _CallFuncPtrVectorCallback = plg::vector (*)(FuncPtrVector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncPtrVectorCallback __cross_call_master_CallFuncPtrVectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return ptr64[] + */ + inline plg::vector CallFuncPtrVectorCallback(FuncPtrVector func) { + return __cross_call_master_CallFuncPtrVectorCallback(func); + } + + using _CallFuncFloatVectorCallback = plg::vector (*)(FuncFloatVector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncFloatVectorCallback __cross_call_master_CallFuncFloatVectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return float[] + */ + inline plg::vector CallFuncFloatVectorCallback(FuncFloatVector func) { + return __cross_call_master_CallFuncFloatVectorCallback(func); + } + + using _CallFuncDoubleVectorCallback = plg::vector (*)(FuncDoubleVector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncDoubleVectorCallback __cross_call_master_CallFuncDoubleVectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return double[] + */ + inline plg::vector CallFuncDoubleVectorCallback(FuncDoubleVector func) { + return __cross_call_master_CallFuncDoubleVectorCallback(func); + } + + using _CallFuncStringVectorCallback = plg::vector (*)(FuncStringVector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncStringVectorCallback __cross_call_master_CallFuncStringVectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return string[] + */ + inline plg::vector CallFuncStringVectorCallback(FuncStringVector func) { + return __cross_call_master_CallFuncStringVectorCallback(func); + } + + using _CallFuncAnyVectorCallback = plg::vector (*)(FuncAnyVector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncAnyVectorCallback __cross_call_master_CallFuncAnyVectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return any[] + */ + inline plg::vector CallFuncAnyVectorCallback(FuncAnyVector func) { + return __cross_call_master_CallFuncAnyVectorCallback(func); + } + + using _CallFuncVec2VectorCallback = plg::vector (*)(FuncVec2Vector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncVec2VectorCallback __cross_call_master_CallFuncVec2VectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return vec2[] + */ + inline plg::vector CallFuncVec2VectorCallback(FuncVec2Vector func) { + return __cross_call_master_CallFuncVec2VectorCallback(func); + } + + using _CallFuncVec3VectorCallback = plg::vector (*)(FuncVec3Vector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncVec3VectorCallback __cross_call_master_CallFuncVec3VectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return vec3[] + */ + inline plg::vector CallFuncVec3VectorCallback(FuncVec3Vector func) { + return __cross_call_master_CallFuncVec3VectorCallback(func); + } + + using _CallFuncVec4VectorCallback = plg::vector (*)(FuncVec4Vector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncVec4VectorCallback __cross_call_master_CallFuncVec4VectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return vec4[] + */ + inline plg::vector CallFuncVec4VectorCallback(FuncVec4Vector func) { + return __cross_call_master_CallFuncVec4VectorCallback(func); + } + + using _CallFuncMat4x4VectorCallback = plg::vector (*)(FuncMat4x4Vector); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncMat4x4VectorCallback __cross_call_master_CallFuncMat4x4VectorCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return mat4x4[] + */ + inline plg::vector CallFuncMat4x4VectorCallback(FuncMat4x4Vector func) { + return __cross_call_master_CallFuncMat4x4VectorCallback(func); + } + + using _CallFuncVec2Callback = plg::vec2 (*)(FuncVec2); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncVec2Callback __cross_call_master_CallFuncVec2Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return vec2 + */ + inline plg::vec2 CallFuncVec2Callback(FuncVec2 func) { + return __cross_call_master_CallFuncVec2Callback(func); + } + + using _CallFuncVec3Callback = plg::vec3 (*)(FuncVec3); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncVec3Callback __cross_call_master_CallFuncVec3Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return vec3 + */ + inline plg::vec3 CallFuncVec3Callback(FuncVec3 func) { + return __cross_call_master_CallFuncVec3Callback(func); + } + + using _CallFuncVec4Callback = plg::vec4 (*)(FuncVec4); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncVec4Callback __cross_call_master_CallFuncVec4Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return vec4 + */ + inline plg::vec4 CallFuncVec4Callback(FuncVec4 func) { + return __cross_call_master_CallFuncVec4Callback(func); + } + + using _CallFuncMat4x4Callback = plg::mat4x4 (*)(FuncMat4x4); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncMat4x4Callback __cross_call_master_CallFuncMat4x4Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return mat4x4 + */ + inline plg::mat4x4 CallFuncMat4x4Callback(FuncMat4x4 func) { + return __cross_call_master_CallFuncMat4x4Callback(func); + } + + using _CallFunc1Callback = int32_t (*)(Func1); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc1Callback __cross_call_master_CallFunc1Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return int32 + */ + inline int32_t CallFunc1Callback(Func1 func) { + return __cross_call_master_CallFunc1Callback(func); + } + + using _CallFunc2Callback = char (*)(Func2); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc2Callback __cross_call_master_CallFunc2Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return char8 + */ + inline char CallFunc2Callback(Func2 func) { + return __cross_call_master_CallFunc2Callback(func); + } + + using _CallFunc3Callback = void (*)(Func3); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc3Callback __cross_call_master_CallFunc3Callback; +namespace cross_call_master { + /** + * @param func (function) + */ + inline void CallFunc3Callback(Func3 func) { + return __cross_call_master_CallFunc3Callback(func); + } + + using _CallFunc4Callback = plg::vec4 (*)(Func4); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc4Callback __cross_call_master_CallFunc4Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return vec4 + */ + inline plg::vec4 CallFunc4Callback(Func4 func) { + return __cross_call_master_CallFunc4Callback(func); + } + + using _CallFunc5Callback = bool (*)(Func5); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc5Callback __cross_call_master_CallFunc5Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return bool + */ + inline bool CallFunc5Callback(Func5 func) { + return __cross_call_master_CallFunc5Callback(func); + } + + using _CallFunc6Callback = int64_t (*)(Func6); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc6Callback __cross_call_master_CallFunc6Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return int64 + */ + inline int64_t CallFunc6Callback(Func6 func) { + return __cross_call_master_CallFunc6Callback(func); + } + + using _CallFunc7Callback = double (*)(Func7); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc7Callback __cross_call_master_CallFunc7Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return double + */ + inline double CallFunc7Callback(Func7 func) { + return __cross_call_master_CallFunc7Callback(func); + } + + using _CallFunc8Callback = plg::mat4x4 (*)(Func8); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc8Callback __cross_call_master_CallFunc8Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return mat4x4 + */ + inline plg::mat4x4 CallFunc8Callback(Func8 func) { + return __cross_call_master_CallFunc8Callback(func); + } + + using _CallFunc9Callback = void (*)(Func9); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc9Callback __cross_call_master_CallFunc9Callback; +namespace cross_call_master { + /** + * @param func (function) + */ + inline void CallFunc9Callback(Func9 func) { + return __cross_call_master_CallFunc9Callback(func); + } + + using _CallFunc10Callback = uint32_t (*)(Func10); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc10Callback __cross_call_master_CallFunc10Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return uint32 + */ + inline uint32_t CallFunc10Callback(Func10 func) { + return __cross_call_master_CallFunc10Callback(func); + } + + using _CallFunc11Callback = void* (*)(Func11); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc11Callback __cross_call_master_CallFunc11Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return ptr64 + */ + inline void* CallFunc11Callback(Func11 func) { + return __cross_call_master_CallFunc11Callback(func); + } + + using _CallFunc12Callback = bool (*)(Func12); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc12Callback __cross_call_master_CallFunc12Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return bool + */ + inline bool CallFunc12Callback(Func12 func) { + return __cross_call_master_CallFunc12Callback(func); + } + + using _CallFunc13Callback = plg::string (*)(Func13); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc13Callback __cross_call_master_CallFunc13Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc13Callback(Func13 func) { + return __cross_call_master_CallFunc13Callback(func); + } + + using _CallFunc14Callback = plg::vector (*)(Func14); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc14Callback __cross_call_master_CallFunc14Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string[] + */ + inline plg::vector CallFunc14Callback(Func14 func) { + return __cross_call_master_CallFunc14Callback(func); + } + + using _CallFunc15Callback = int16_t (*)(Func15); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc15Callback __cross_call_master_CallFunc15Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return int16 + */ + inline int16_t CallFunc15Callback(Func15 func) { + return __cross_call_master_CallFunc15Callback(func); + } + + using _CallFunc16Callback = void* (*)(Func16); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc16Callback __cross_call_master_CallFunc16Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return ptr64 + */ + inline void* CallFunc16Callback(Func16 func) { + return __cross_call_master_CallFunc16Callback(func); + } + + using _CallFunc17Callback = plg::string (*)(Func17); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc17Callback __cross_call_master_CallFunc17Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc17Callback(Func17 func) { + return __cross_call_master_CallFunc17Callback(func); + } + + using _CallFunc18Callback = plg::string (*)(Func18); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc18Callback __cross_call_master_CallFunc18Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc18Callback(Func18 func) { + return __cross_call_master_CallFunc18Callback(func); + } + + using _CallFunc19Callback = plg::string (*)(Func19); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc19Callback __cross_call_master_CallFunc19Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc19Callback(Func19 func) { + return __cross_call_master_CallFunc19Callback(func); + } + + using _CallFunc20Callback = plg::string (*)(Func20); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc20Callback __cross_call_master_CallFunc20Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc20Callback(Func20 func) { + return __cross_call_master_CallFunc20Callback(func); + } + + using _CallFunc21Callback = plg::string (*)(Func21); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc21Callback __cross_call_master_CallFunc21Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc21Callback(Func21 func) { + return __cross_call_master_CallFunc21Callback(func); + } + + using _CallFunc22Callback = plg::string (*)(Func22); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc22Callback __cross_call_master_CallFunc22Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc22Callback(Func22 func) { + return __cross_call_master_CallFunc22Callback(func); + } + + using _CallFunc23Callback = plg::string (*)(Func23); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc23Callback __cross_call_master_CallFunc23Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc23Callback(Func23 func) { + return __cross_call_master_CallFunc23Callback(func); + } + + using _CallFunc24Callback = plg::string (*)(Func24); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc24Callback __cross_call_master_CallFunc24Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc24Callback(Func24 func) { + return __cross_call_master_CallFunc24Callback(func); + } + + using _CallFunc25Callback = plg::string (*)(Func25); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc25Callback __cross_call_master_CallFunc25Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc25Callback(Func25 func) { + return __cross_call_master_CallFunc25Callback(func); + } + + using _CallFunc26Callback = plg::string (*)(Func26); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc26Callback __cross_call_master_CallFunc26Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc26Callback(Func26 func) { + return __cross_call_master_CallFunc26Callback(func); + } + + using _CallFunc27Callback = plg::string (*)(Func27); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc27Callback __cross_call_master_CallFunc27Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc27Callback(Func27 func) { + return __cross_call_master_CallFunc27Callback(func); + } + + using _CallFunc28Callback = plg::string (*)(Func28); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc28Callback __cross_call_master_CallFunc28Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc28Callback(Func28 func) { + return __cross_call_master_CallFunc28Callback(func); + } + + using _CallFunc29Callback = plg::string (*)(Func29); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc29Callback __cross_call_master_CallFunc29Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc29Callback(Func29 func) { + return __cross_call_master_CallFunc29Callback(func); + } + + using _CallFunc30Callback = plg::string (*)(Func30); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc30Callback __cross_call_master_CallFunc30Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc30Callback(Func30 func) { + return __cross_call_master_CallFunc30Callback(func); + } + + using _CallFunc31Callback = plg::string (*)(Func31); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc31Callback __cross_call_master_CallFunc31Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc31Callback(Func31 func) { + return __cross_call_master_CallFunc31Callback(func); + } + + using _CallFunc32Callback = plg::string (*)(Func32); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc32Callback __cross_call_master_CallFunc32Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc32Callback(Func32 func) { + return __cross_call_master_CallFunc32Callback(func); + } + + using _CallFunc33Callback = plg::string (*)(Func33); +} +extern "C" PLUGIN_API cross_call_master::_CallFunc33Callback __cross_call_master_CallFunc33Callback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFunc33Callback(Func33 func) { + return __cross_call_master_CallFunc33Callback(func); + } + + using _CallFuncEnumCallback = plg::string (*)(FuncEnum); +} +extern "C" PLUGIN_API cross_call_master::_CallFuncEnumCallback __cross_call_master_CallFuncEnumCallback; +namespace cross_call_master { + /** + * @param func (function) + * @return string + */ + inline plg::string CallFuncEnumCallback(FuncEnum func) { + return __cross_call_master_CallFuncEnumCallback(func); + } + + /** + * @brief RAII wrapper for ResourceHandle pointer + */ + class ResourceHandle final { + public: + /** + * @param id (int32) + * @param name (string) + */ + explicit ResourceHandle(int32_t id, const plg::string& name) + : ResourceHandle(ResourceHandleCreate(id, name), Ownership::Owned) {} + + /** + */ + explicit ResourceHandle() + : ResourceHandle(ResourceHandleCreateDefault(), Ownership::Owned) {} + + ~ResourceHandle() { + destroy(); + } + + ResourceHandle(const ResourceHandle&) = delete; + ResourceHandle& operator=(const ResourceHandle&) = delete; + + ResourceHandle(ResourceHandle&& other) noexcept + : _handle(other._handle) + , _ownership(other._ownership) { + other.nullify(); + } + + ResourceHandle& operator=(ResourceHandle&& other) noexcept { + if (this != &other) { + destroy(); + _handle = other._handle; + _ownership = other._ownership; + other.nullify(); + } + return *this; + } + + ResourceHandle(void* handle, Ownership ownership = Ownership::Borrowed) : _handle(handle), _ownership(ownership) {} + + [[nodiscard]] auto get() const noexcept { return _handle; } + + [[nodiscard]] auto release() noexcept { + auto handle = _handle; + nullify(); + return handle; + } + + void reset() noexcept { + destroy(); + nullify(); + } + + void swap(ResourceHandle& other) noexcept { + using std::swap; + swap(_handle, other._handle); + swap(_ownership, other._ownership); + } + + friend void swap(ResourceHandle& lhs, ResourceHandle& rhs) noexcept { lhs.swap(rhs); } + + explicit operator bool() const noexcept { return _handle != nullptr; } + [[nodiscard]] auto operator<=>(const ResourceHandle& other) const noexcept { return _handle <=> other._handle; } + [[nodiscard]] bool operator==(const ResourceHandle& other) const noexcept { return _handle == other._handle; } + + /** + * @return int32 + */ + int32_t GetId() { + if (_handle == nullptr) throw std::runtime_error("ResourceHandle: Empty handle"); + return cross_call_master::ResourceHandleGetId(_handle); + } + + /** + * @return string + */ + plg::string GetName() { + if (_handle == nullptr) throw std::runtime_error("ResourceHandle: Empty handle"); + return cross_call_master::ResourceHandleGetName(_handle); + } + + /** + * @param name (string) + */ + void SetName(const plg::string& name) { + if (_handle == nullptr) throw std::runtime_error("ResourceHandle: Empty handle"); + cross_call_master::ResourceHandleSetName(_handle, name); + } + + /** + */ + void IncrementCounter() { + if (_handle == nullptr) throw std::runtime_error("ResourceHandle: Empty handle"); + cross_call_master::ResourceHandleIncrementCounter(_handle); + } + + /** + * @return int32 + */ + int32_t GetCounter() { + if (_handle == nullptr) throw std::runtime_error("ResourceHandle: Empty handle"); + return cross_call_master::ResourceHandleGetCounter(_handle); + } + + /** + * @param value (float) + */ + void AddData(float value) { + if (_handle == nullptr) throw std::runtime_error("ResourceHandle: Empty handle"); + cross_call_master::ResourceHandleAddData(_handle, value); + } + + /** + * @return float[] + */ + plg::vector GetData() { + if (_handle == nullptr) throw std::runtime_error("ResourceHandle: Empty handle"); + return cross_call_master::ResourceHandleGetData(_handle); + } + + /** + * @return int32 + */ + static int32_t GetAliveCount() { + return cross_call_master::ResourceHandleGetAliveCount(); + } + + /** + * @return int32 + */ + static int32_t GetTotalCreated() { + return cross_call_master::ResourceHandleGetTotalCreated(); + } + + /** + * @return int32 + */ + static int32_t GetTotalDestroyed() { + return cross_call_master::ResourceHandleGetTotalDestroyed(); + } + + private: + void destroy() const noexcept { + if (_handle != nullptr && _ownership == Ownership::Owned) { + ResourceHandleDestroy(_handle); + } + } + + void nullify() noexcept { + _handle = nullptr; + _ownership = Ownership::Borrowed; + } + + void* _handle{nullptr}; + Ownership _ownership{Ownership::Borrowed}; + }; + + + /** + */ + class Counter final { + public: + /** + * @param initialValue (int64) + */ + explicit Counter(int64_t initialValue) + : Counter(CounterCreate(initialValue), Ownership::Owned) {} + + /** + */ + explicit Counter() + : Counter(CounterCreateZero(), Ownership::Owned) {} + + Counter(const Counter&) = default; + Counter& operator=(const Counter&) = default; + Counter(Counter&&) noexcept = default; + Counter& operator=(Counter&&) noexcept = default; + ~Counter() = default; + + explicit Counter(void* handle, [[maybe_unused]] Ownership ownership = Ownership::Borrowed) : _handle(handle) {} + + [[nodiscard]] auto get() const noexcept { return _handle; } + + [[nodiscard]] auto release() noexcept { + auto handle = _handle; + _handle = nullptr; + return handle; + } + + void reset() noexcept { + _handle = nullptr; + } + + void swap(Counter& other) noexcept { + using std::swap; + swap(_handle, other._handle); + } + + friend void swap(Counter& lhs, Counter& rhs) noexcept { lhs.swap(rhs); } + + explicit operator bool() const noexcept { return _handle != nullptr; } + [[nodiscard]] auto operator<=>(const Counter& other) const noexcept { return _handle <=> other._handle; } + [[nodiscard]] bool operator==(const Counter& other) const noexcept { return _handle == other._handle; } + + /** + * @return int64 + */ + int64_t GetValue() { + if (_handle == nullptr) throw std::runtime_error("Counter: Empty handle"); + return cross_call_master::CounterGetValue(_handle); + } + + /** + * @param value (int64) + */ + void SetValue(int64_t value) { + if (_handle == nullptr) throw std::runtime_error("Counter: Empty handle"); + cross_call_master::CounterSetValue(_handle, value); + } + + /** + */ + void Increment() { + if (_handle == nullptr) throw std::runtime_error("Counter: Empty handle"); + cross_call_master::CounterIncrement(_handle); + } + + /** + */ + void Decrement() { + if (_handle == nullptr) throw std::runtime_error("Counter: Empty handle"); + cross_call_master::CounterDecrement(_handle); + } + + /** + * @param amount (int64) + */ + void Add(int64_t amount) { + if (_handle == nullptr) throw std::runtime_error("Counter: Empty handle"); + cross_call_master::CounterAdd(_handle, amount); + } + + /** + */ + void Reset() { + if (_handle == nullptr) throw std::runtime_error("Counter: Empty handle"); + cross_call_master::CounterReset(_handle); + } + + /** + * @return bool + */ + bool IsPositive() { + if (_handle == nullptr) throw std::runtime_error("Counter: Empty handle"); + return cross_call_master::CounterIsPositive(_handle); + } + + /** + * @param value1 (int64) + * @param value2 (int64) + * @return int32 + */ + static int32_t Compare(int64_t value1, int64_t value2) { + return cross_call_master::CounterCompare(value1, value2); + } + + /** + * @param values (int64[]) + * @return int64 + */ + static int64_t Sum(const plg::vector& values) { + return cross_call_master::CounterSum(values); + } + + private: + void* _handle{nullptr}; + }; + + +} // namespace cross_call_master diff --git a/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/counter.hpp b/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/counter.hpp new file mode 100644 index 0000000..0d49f6d --- /dev/null +++ b/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/counter.hpp @@ -0,0 +1,140 @@ +#pragma once + +#include + +#include "enums.hpp" +#include "delegates.hpp" +// Generated from cross_call_master.pplugin (group: counter) + +namespace cross_call_master { + + using _CounterCreate = void* (*)(int64_t); +} +extern "C" PLUGIN_API cross_call_master::_CounterCreate __cross_call_master_CounterCreate; +namespace cross_call_master { + /** + * @param initialValue (int64) + * @return ptr64 + */ + inline void* CounterCreate(int64_t initialValue) { + return __cross_call_master_CounterCreate(initialValue); + } + + using _CounterCreateZero = void* (*)(); +} +extern "C" PLUGIN_API cross_call_master::_CounterCreateZero __cross_call_master_CounterCreateZero; +namespace cross_call_master { + /** + * @return ptr64 + */ + inline void* CounterCreateZero() { + return __cross_call_master_CounterCreateZero(); + } + + using _CounterGetValue = int64_t (*)(void*); +} +extern "C" PLUGIN_API cross_call_master::_CounterGetValue __cross_call_master_CounterGetValue; +namespace cross_call_master { + /** + * @param counter (ptr64) + * @return int64 + */ + inline int64_t CounterGetValue(void* counter) { + return __cross_call_master_CounterGetValue(counter); + } + + using _CounterSetValue = void (*)(void*, int64_t); +} +extern "C" PLUGIN_API cross_call_master::_CounterSetValue __cross_call_master_CounterSetValue; +namespace cross_call_master { + /** + * @param counter (ptr64) + * @param value (int64) + */ + inline void CounterSetValue(void* counter, int64_t value) { + return __cross_call_master_CounterSetValue(counter, value); + } + + using _CounterIncrement = void (*)(void*); +} +extern "C" PLUGIN_API cross_call_master::_CounterIncrement __cross_call_master_CounterIncrement; +namespace cross_call_master { + /** + * @param counter (ptr64) + */ + inline void CounterIncrement(void* counter) { + return __cross_call_master_CounterIncrement(counter); + } + + using _CounterDecrement = void (*)(void*); +} +extern "C" PLUGIN_API cross_call_master::_CounterDecrement __cross_call_master_CounterDecrement; +namespace cross_call_master { + /** + * @param counter (ptr64) + */ + inline void CounterDecrement(void* counter) { + return __cross_call_master_CounterDecrement(counter); + } + + using _CounterAdd = void (*)(void*, int64_t); +} +extern "C" PLUGIN_API cross_call_master::_CounterAdd __cross_call_master_CounterAdd; +namespace cross_call_master { + /** + * @param counter (ptr64) + * @param amount (int64) + */ + inline void CounterAdd(void* counter, int64_t amount) { + return __cross_call_master_CounterAdd(counter, amount); + } + + using _CounterReset = void (*)(void*); +} +extern "C" PLUGIN_API cross_call_master::_CounterReset __cross_call_master_CounterReset; +namespace cross_call_master { + /** + * @param counter (ptr64) + */ + inline void CounterReset(void* counter) { + return __cross_call_master_CounterReset(counter); + } + + using _CounterIsPositive = bool (*)(void*); +} +extern "C" PLUGIN_API cross_call_master::_CounterIsPositive __cross_call_master_CounterIsPositive; +namespace cross_call_master { + /** + * @param counter (ptr64) + * @return bool + */ + inline bool CounterIsPositive(void* counter) { + return __cross_call_master_CounterIsPositive(counter); + } + + using _CounterCompare = int32_t (*)(int64_t, int64_t); +} +extern "C" PLUGIN_API cross_call_master::_CounterCompare __cross_call_master_CounterCompare; +namespace cross_call_master { + /** + * @param value1 (int64) + * @param value2 (int64) + * @return int32 + */ + inline int32_t CounterCompare(int64_t value1, int64_t value2) { + return __cross_call_master_CounterCompare(value1, value2); + } + + using _CounterSum = int64_t (*)(const plg::vector&); +} +extern "C" PLUGIN_API cross_call_master::_CounterSum __cross_call_master_CounterSum; +namespace cross_call_master { + /** + * @param values (int64[]) + * @return int64 + */ + inline int64_t CounterSum(const plg::vector& values) { + return __cross_call_master_CounterSum(values); + } + +} // namespace cross_call_master diff --git a/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/delegates.hpp b/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/delegates.hpp new file mode 100644 index 0000000..264d049 --- /dev/null +++ b/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/delegates.hpp @@ -0,0 +1,165 @@ +#pragma once + +#include "enums.hpp" +#include +#include + +// Generated from cross_call_master.pplugin + +namespace cross_call_master { + + using NoParamReturnFunctionCallbackFunc = int32_t (*)(); + + using FuncVoid = void (*)(); + + using FuncBool = bool (*)(); + + using FuncChar8 = char (*)(); + + using FuncChar16 = char16_t (*)(); + + using FuncInt8 = int8_t (*)(); + + using FuncInt16 = int16_t (*)(); + + using FuncInt32 = int32_t (*)(); + + using FuncInt64 = int64_t (*)(); + + using FuncUInt8 = uint8_t (*)(); + + using FuncUInt16 = uint16_t (*)(); + + using FuncUInt32 = uint32_t (*)(); + + using FuncUInt64 = uint64_t (*)(); + + using FuncPtr = void* (*)(); + + using FuncFloat = float (*)(); + + using FuncDouble = double (*)(); + + using FuncString = plg::string (*)(); + + using FuncAny = plg::any (*)(); + + using FuncFunction = void* (*)(); + + using FuncBoolVector = plg::vector (*)(); + + using FuncChar8Vector = plg::vector (*)(); + + using FuncChar16Vector = plg::vector (*)(); + + using FuncInt8Vector = plg::vector (*)(); + + using FuncInt16Vector = plg::vector (*)(); + + using FuncInt32Vector = plg::vector (*)(); + + using FuncInt64Vector = plg::vector (*)(); + + using FuncUInt8Vector = plg::vector (*)(); + + using FuncUInt16Vector = plg::vector (*)(); + + using FuncUInt32Vector = plg::vector (*)(); + + using FuncUInt64Vector = plg::vector (*)(); + + using FuncPtrVector = plg::vector (*)(); + + using FuncFloatVector = plg::vector (*)(); + + using FuncDoubleVector = plg::vector (*)(); + + using FuncStringVector = plg::vector (*)(); + + using FuncAnyVector = plg::vector (*)(); + + using FuncVec2Vector = plg::vector (*)(); + + using FuncVec3Vector = plg::vector (*)(); + + using FuncVec4Vector = plg::vector (*)(); + + using FuncMat4x4Vector = plg::vector (*)(); + + using FuncVec2 = plg::vec2 (*)(); + + using FuncVec3 = plg::vec3 (*)(); + + using FuncVec4 = plg::vec4 (*)(); + + using FuncMat4x4 = plg::mat4x4 (*)(); + + using Func1 = int32_t (*)(const plg::vec3&); + + using Func2 = char (*)(float, int64_t); + + using Func3 = void (*)(void*, const plg::vec4&, const plg::string&); + + using Func4 = plg::vec4 (*)(bool, int32_t, char16_t, const plg::mat4x4&); + + using Func5 = bool (*)(int8_t, const plg::vec2&, void*, double, const plg::vector&); + + using Func6 = int64_t (*)(const plg::string&, float, const plg::vector&, int16_t, const plg::vector&, void*); + + using Func7 = double (*)(const plg::vector&, uint16_t, char16_t, const plg::vector&, const plg::vec4&, bool, uint64_t); + + using Func8 = plg::mat4x4 (*)(const plg::vec3&, const plg::vector&, int16_t, bool, const plg::vec4&, const plg::vector&, char16_t, int32_t); + + using Func9 = void (*)(float, const plg::vec2&, const plg::vector&, uint64_t, bool, const plg::string&, const plg::vec4&, int16_t, void*); + + using Func10 = uint32_t (*)(const plg::vec4&, const plg::mat4x4&, const plg::vector&, uint64_t, const plg::vector&, int32_t, bool, const plg::vec2&, int64_t, double); + + using Func11 = void* (*)(const plg::vector&, char16_t, uint8_t, double, const plg::vec3&, const plg::vector&, int64_t, uint16_t, float, const plg::vec2&, uint32_t); + + using Func12 = bool (*)(void*, const plg::vector&, uint32_t, double, bool, int32_t, int8_t, uint64_t, float, const plg::vector&, int64_t, char); + + using Func13 = plg::string (*)(int64_t, const plg::vector&, uint16_t, float, const plg::vector&, const plg::vec4&, const plg::string&, int32_t, const plg::vec3&, void*, const plg::vec2&, const plg::vector&, int16_t); + + using Func14 = plg::vector (*)(const plg::vector&, const plg::vector&, const plg::mat4x4&, bool, char16_t, int32_t, const plg::vector&, uint16_t, const plg::vector&, int8_t, const plg::vec3&, const plg::vec4&, double, void*); + + using Func15 = int16_t (*)(const plg::vector&, const plg::mat4x4&, const plg::vec4&, void*, uint64_t, const plg::vector&, bool, float, const plg::vector&, uint8_t, int32_t, const plg::vec2&, uint16_t, double, const plg::vector&); + + using Func16 = void* (*)(const plg::vector&, int16_t, const plg::vector&, const plg::vec4&, const plg::mat4x4&, const plg::vec2&, const plg::vector&, const plg::vector&, const plg::string&, int64_t, const plg::vector&, const plg::vec3&, float, double, int8_t, uint16_t); + + using Func17 = void (*)(int32_t&); + + using Func18 = plg::vec2 (*)(int8_t&, int16_t&); + + using Func19 = void (*)(uint32_t&, plg::vec3&, plg::vector&); + + using Func20 = int32_t (*)(char16_t&, plg::vec4&, plg::vector&, char&); + + using Func21 = float (*)(plg::mat4x4&, plg::vector&, plg::vec2&, bool&, double&); + + using Func22 = uint64_t (*)(void*&, uint32_t&, plg::vector&, int16_t&, plg::string&, plg::vec4&); + + using Func23 = void (*)(uint64_t&, plg::vec2&, plg::vector&, char16_t&, float&, int8_t&, plg::vector&); + + using Func24 = plg::mat4x4 (*)(plg::vector&, int64_t&, plg::vector&, plg::vec4&, uint64_t&, plg::vector&, double&, plg::vector&); + + using Func25 = double (*)(int32_t&, plg::vector&, bool&, uint8_t&, plg::string&, plg::vec3&, int64_t&, plg::vec4&, uint16_t&); + + using Func26 = char (*)(char16_t&, plg::vec2&, plg::mat4x4&, plg::vector&, int16_t&, uint64_t&, uint32_t&, plg::vector&, void*&, bool&); + + using Func27 = uint8_t (*)(float&, plg::vec3&, void*&, plg::vec2&, plg::vector&, plg::mat4x4&, bool&, plg::vec4&, int8_t&, int32_t&, plg::vector&); + + using Func28 = plg::string (*)(void*&, uint16_t&, plg::vector&, plg::mat4x4&, float&, plg::vec4&, plg::string&, plg::vector&, int64_t&, bool&, plg::vec3&, plg::vector&); + + using Func29 = plg::vector (*)(plg::vec4&, int32_t&, plg::vector&, double&, bool&, int8_t&, plg::vector&, float&, plg::string&, plg::mat4x4&, uint64_t&, plg::vec3&, plg::vector&); + + using Func30 = int32_t (*)(void*&, plg::vec4&, int64_t&, plg::vector&, bool&, plg::string&, plg::vec3&, plg::vector&, float&, plg::vec2&, plg::mat4x4&, int8_t&, plg::vector&, double&); + + using Func31 = plg::vec3 (*)(char&, uint32_t&, plg::vector&, plg::vec4&, plg::string&, bool&, int64_t&, plg::vec2&, int8_t&, uint16_t&, plg::vector&, plg::mat4x4&, plg::vec3&, float&, plg::vector&); + + using Func32 = double (*)(int32_t&, uint16_t&, plg::vector&, plg::vec4&, void*&, plg::vector&, plg::mat4x4&, uint64_t&, plg::string&, int64_t&, plg::vec2&, plg::vector&, bool&, plg::vec3&, uint8_t&, plg::vector&); + + using Func33 = void (*)(plg::any&); + + using FuncEnum = plg::vector (*)(Example, plg::vector&); + +} // namespace cross_call_master diff --git a/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/enums.hpp b/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/enums.hpp new file mode 100644 index 0000000..dcfd0bb --- /dev/null +++ b/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/enums.hpp @@ -0,0 +1,19 @@ +#pragma once + +#include +// Generated from cross_call_master.pplugin + +namespace cross_call_master { + + enum class Example : int32_t { + First = 1, + Second = 2, + Third = 3, + Forth = 4 + }; + + + /// Ownership type for RAII wrappers + enum class Ownership : bool { Borrowed, Owned }; + +} // namespace cross_call_master diff --git a/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/resource.hpp b/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/resource.hpp new file mode 100644 index 0000000..83f50d3 --- /dev/null +++ b/test/cross_call_worker/external/plugify/include/cross_call_master/cross_call_master/resource.hpp @@ -0,0 +1,162 @@ +#pragma once + +#include + +#include "enums.hpp" +#include "delegates.hpp" +// Generated from cross_call_master.pplugin (group: resource) + +namespace cross_call_master { + + using _ResourceHandleCreate = void* (*)(int32_t, const plg::string&); +} +extern "C" PLUGIN_API cross_call_master::_ResourceHandleCreate __cross_call_master_ResourceHandleCreate; +namespace cross_call_master { + /** + * @param id (int32) + * @param name (string) + * @return ptr64 + */ + inline void* ResourceHandleCreate(int32_t id, const plg::string& name) { + return __cross_call_master_ResourceHandleCreate(id, name); + } + + using _ResourceHandleCreateDefault = void* (*)(); +} +extern "C" PLUGIN_API cross_call_master::_ResourceHandleCreateDefault __cross_call_master_ResourceHandleCreateDefault; +namespace cross_call_master { + /** + * @return ptr64 + */ + inline void* ResourceHandleCreateDefault() { + return __cross_call_master_ResourceHandleCreateDefault(); + } + + using _ResourceHandleDestroy = void (*)(void*); +} +extern "C" PLUGIN_API cross_call_master::_ResourceHandleDestroy __cross_call_master_ResourceHandleDestroy; +namespace cross_call_master { + /** + * @param handle (ptr64) + */ + inline void ResourceHandleDestroy(void* handle) { + return __cross_call_master_ResourceHandleDestroy(handle); + } + + using _ResourceHandleGetId = int32_t (*)(void*); +} +extern "C" PLUGIN_API cross_call_master::_ResourceHandleGetId __cross_call_master_ResourceHandleGetId; +namespace cross_call_master { + /** + * @param handle (ptr64) + * @return int32 + */ + inline int32_t ResourceHandleGetId(void* handle) { + return __cross_call_master_ResourceHandleGetId(handle); + } + + using _ResourceHandleGetName = plg::string (*)(void*); +} +extern "C" PLUGIN_API cross_call_master::_ResourceHandleGetName __cross_call_master_ResourceHandleGetName; +namespace cross_call_master { + /** + * @param handle (ptr64) + * @return string + */ + inline plg::string ResourceHandleGetName(void* handle) { + return __cross_call_master_ResourceHandleGetName(handle); + } + + using _ResourceHandleSetName = void (*)(void*, const plg::string&); +} +extern "C" PLUGIN_API cross_call_master::_ResourceHandleSetName __cross_call_master_ResourceHandleSetName; +namespace cross_call_master { + /** + * @param handle (ptr64) + * @param name (string) + */ + inline void ResourceHandleSetName(void* handle, const plg::string& name) { + return __cross_call_master_ResourceHandleSetName(handle, name); + } + + using _ResourceHandleIncrementCounter = void (*)(void*); +} +extern "C" PLUGIN_API cross_call_master::_ResourceHandleIncrementCounter __cross_call_master_ResourceHandleIncrementCounter; +namespace cross_call_master { + /** + * @param handle (ptr64) + */ + inline void ResourceHandleIncrementCounter(void* handle) { + return __cross_call_master_ResourceHandleIncrementCounter(handle); + } + + using _ResourceHandleGetCounter = int32_t (*)(void*); +} +extern "C" PLUGIN_API cross_call_master::_ResourceHandleGetCounter __cross_call_master_ResourceHandleGetCounter; +namespace cross_call_master { + /** + * @param handle (ptr64) + * @return int32 + */ + inline int32_t ResourceHandleGetCounter(void* handle) { + return __cross_call_master_ResourceHandleGetCounter(handle); + } + + using _ResourceHandleAddData = void (*)(void*, float); +} +extern "C" PLUGIN_API cross_call_master::_ResourceHandleAddData __cross_call_master_ResourceHandleAddData; +namespace cross_call_master { + /** + * @param handle (ptr64) + * @param value (float) + */ + inline void ResourceHandleAddData(void* handle, float value) { + return __cross_call_master_ResourceHandleAddData(handle, value); + } + + using _ResourceHandleGetData = plg::vector (*)(void*); +} +extern "C" PLUGIN_API cross_call_master::_ResourceHandleGetData __cross_call_master_ResourceHandleGetData; +namespace cross_call_master { + /** + * @param handle (ptr64) + * @return float[] + */ + inline plg::vector ResourceHandleGetData(void* handle) { + return __cross_call_master_ResourceHandleGetData(handle); + } + + using _ResourceHandleGetAliveCount = int32_t (*)(); +} +extern "C" PLUGIN_API cross_call_master::_ResourceHandleGetAliveCount __cross_call_master_ResourceHandleGetAliveCount; +namespace cross_call_master { + /** + * @return int32 + */ + inline int32_t ResourceHandleGetAliveCount() { + return __cross_call_master_ResourceHandleGetAliveCount(); + } + + using _ResourceHandleGetTotalCreated = int32_t (*)(); +} +extern "C" PLUGIN_API cross_call_master::_ResourceHandleGetTotalCreated __cross_call_master_ResourceHandleGetTotalCreated; +namespace cross_call_master { + /** + * @return int32 + */ + inline int32_t ResourceHandleGetTotalCreated() { + return __cross_call_master_ResourceHandleGetTotalCreated(); + } + + using _ResourceHandleGetTotalDestroyed = int32_t (*)(); +} +extern "C" PLUGIN_API cross_call_master::_ResourceHandleGetTotalDestroyed __cross_call_master_ResourceHandleGetTotalDestroyed; +namespace cross_call_master { + /** + * @return int32 + */ + inline int32_t ResourceHandleGetTotalDestroyed() { + return __cross_call_master_ResourceHandleGetTotalDestroyed(); + } + +} // namespace cross_call_master diff --git a/test/cross_call_worker/external/plugify/include/plg/plugin.hpp b/test/cross_call_worker/external/plugify/include/plg/plugin.hpp index 550b623..9308ea9 100644 --- a/test/cross_call_worker/external/plugify/include/plg/plugin.hpp +++ b/test/cross_call_worker/external/plugify/include/plg/plugin.hpp @@ -7,6 +7,7 @@ #include #include #include +#include #include #include "plg/any.hpp" @@ -14,8 +15,6 @@ #include "plg/api.hpp" namespace plg { - using GetMethodPtrFn = void* (*)(std::string_view); - using GetMethodPtr2Fn = void (*)(std::string_view, void**); using GetBaseDirFn = plg::string (*)(); using GetExtensionsDirFn = plg::string (*)(); using GetConfigsDirFn = plg::string (*)(); @@ -24,8 +23,6 @@ namespace plg { using GetCacheDirFn = plg::string (*)(); using IsExtensionLoadedFn = bool (*)(std::string_view, std::optional>); - extern GetMethodPtrFn GetMethodPtr; - extern GetMethodPtr2Fn GetMethodPtr2; extern GetBaseDirFn GetBaseDir; extern GetExtensionsDirFn GetExtensionsDir; extern GetConfigsDirFn GetConfigsDir; @@ -90,8 +87,6 @@ namespace plg { #define EXPOSE_PLUGIN(plugin_api, plugin_class, plugin_addr) \ namespace plg { \ - GetMethodPtrFn GetMethodPtr{nullptr}; \ - GetMethodPtr2Fn GetMethodPtr2{nullptr}; \ GetBaseDirFn GetBaseDir{nullptr}; \ GetExtensionsDirFn GetExtensionsDir{nullptr}; \ GetConfigsDirFn GetConfigsDir{nullptr}; \ @@ -111,13 +106,12 @@ namespace plg { GetLocationFn GetLocation{nullptr}; \ GetDependenciesFn GetDependencies{nullptr}; \ } \ - extern "C" plugin_api int Plugify_Init(void** api, int version, void* handle) { \ + extern "C" plugin_api int Plugify_Init(void** data, size_t len, int version, void* handle) { \ if (version < kApiVersion) { \ return kApiVersion; \ } \ + std::span api(data, len); \ size_t i = 0; \ - GetMethodPtr = reinterpret_cast(api[i++]); \ - GetMethodPtr2 = reinterpret_cast(api[i++]); \ GetBaseDir = reinterpret_cast(api[i++]); \ GetExtensionsDir = reinterpret_cast(api[i++]); \ GetConfigsDir = reinterpret_cast(api[i++]); \ @@ -180,16 +174,17 @@ namespace plg { namespace plg { namespace raw { + template struct vector { - uint8_t pad[sizeof(plg::vector)]{}; + alignas(plg::vector) unsigned char pad[sizeof(plg::vector)]{}; }; struct string { - uint8_t pad[sizeof(plg::string)]{}; + alignas(plg::string) unsigned char pad[sizeof(plg::string)]{}; }; struct variant { - uint8_t pad[sizeof(plg::any)]{}; + alignas(plg::any) unsigned char pad[sizeof(plg::any)]{}; }; } // namespace raw diff --git a/test/cross_call_worker/external/plugify/include/pps/cross_call_master.hpp b/test/cross_call_worker/external/plugify/include/pps/cross_call_master.hpp deleted file mode 100644 index 376ac82..0000000 --- a/test/cross_call_worker/external/plugify/include/pps/cross_call_master.hpp +++ /dev/null @@ -1,2531 +0,0 @@ -#pragma once - -#include -#include -#include -#include - -// Generated from cross_call_master.pplugin - -namespace cross_call_master { - - using NoParamReturnFunctionCallbackFunc = int32_t (*)(); - - enum class Example : int32_t { - First = 1, - Second = 2, - Third = 3, - Forth = 4 - }; - - using FuncVoid = void (*)(); - - using FuncBool = bool (*)(); - - using FuncChar8 = char (*)(); - - using FuncChar16 = char16_t (*)(); - - using FuncInt8 = int8_t (*)(); - - using FuncInt16 = int16_t (*)(); - - using FuncInt32 = int32_t (*)(); - - using FuncInt64 = int64_t (*)(); - - using FuncUInt8 = uint8_t (*)(); - - using FuncUInt16 = uint16_t (*)(); - - using FuncUInt32 = uint32_t (*)(); - - using FuncUInt64 = uint64_t (*)(); - - using FuncPtr = void* (*)(); - - using FuncFloat = float (*)(); - - using FuncDouble = double (*)(); - - using FuncString = plg::string (*)(); - - using FuncAny = plg::any (*)(); - - using FuncFunction = void* (*)(); - - using FuncBoolVector = plg::vector (*)(); - - using FuncChar8Vector = plg::vector (*)(); - - using FuncChar16Vector = plg::vector (*)(); - - using FuncInt8Vector = plg::vector (*)(); - - using FuncInt16Vector = plg::vector (*)(); - - using FuncInt32Vector = plg::vector (*)(); - - using FuncInt64Vector = plg::vector (*)(); - - using FuncUInt8Vector = plg::vector (*)(); - - using FuncUInt16Vector = plg::vector (*)(); - - using FuncUInt32Vector = plg::vector (*)(); - - using FuncUInt64Vector = plg::vector (*)(); - - using FuncPtrVector = plg::vector (*)(); - - using FuncFloatVector = plg::vector (*)(); - - using FuncDoubleVector = plg::vector (*)(); - - using FuncStringVector = plg::vector (*)(); - - using FuncAnyVector = plg::vector (*)(); - - using FuncVec2Vector = plg::vector (*)(); - - using FuncVec3Vector = plg::vector (*)(); - - using FuncVec4Vector = plg::vector (*)(); - - using FuncMat4x4Vector = plg::vector (*)(); - - using FuncVec2 = plg::vec2 (*)(); - - using FuncVec3 = plg::vec3 (*)(); - - using FuncVec4 = plg::vec4 (*)(); - - using FuncMat4x4 = plg::mat4x4 (*)(); - - using Func1 = int32_t (*)(const plg::vec3&); - - using Func2 = char (*)(float, int64_t); - - using Func3 = void (*)(void*, const plg::vec4&, const plg::string&); - - using Func4 = plg::vec4 (*)(bool, int32_t, char16_t, const plg::mat4x4&); - - using Func5 = bool (*)(int8_t, const plg::vec2&, void*, double, const plg::vector&); - - using Func6 = int64_t (*)(const plg::string&, float, const plg::vector&, int16_t, const plg::vector&, void*); - - using Func7 = double (*)(const plg::vector&, uint16_t, char16_t, const plg::vector&, const plg::vec4&, bool, uint64_t); - - using Func8 = plg::mat4x4 (*)(const plg::vec3&, const plg::vector&, int16_t, bool, const plg::vec4&, const plg::vector&, char16_t, int32_t); - - using Func9 = void (*)(float, const plg::vec2&, const plg::vector&, uint64_t, bool, const plg::string&, const plg::vec4&, int16_t, void*); - - using Func10 = uint32_t (*)(const plg::vec4&, const plg::mat4x4&, const plg::vector&, uint64_t, const plg::vector&, int32_t, bool, const plg::vec2&, int64_t, double); - - using Func11 = void* (*)(const plg::vector&, char16_t, uint8_t, double, const plg::vec3&, const plg::vector&, int64_t, uint16_t, float, const plg::vec2&, uint32_t); - - using Func12 = bool (*)(void*, const plg::vector&, uint32_t, double, bool, int32_t, int8_t, uint64_t, float, const plg::vector&, int64_t, char); - - using Func13 = plg::string (*)(int64_t, const plg::vector&, uint16_t, float, const plg::vector&, const plg::vec4&, const plg::string&, int32_t, const plg::vec3&, void*, const plg::vec2&, const plg::vector&, int16_t); - - using Func14 = plg::vector (*)(const plg::vector&, const plg::vector&, const plg::mat4x4&, bool, char16_t, int32_t, const plg::vector&, uint16_t, const plg::vector&, int8_t, const plg::vec3&, const plg::vec4&, double, void*); - - using Func15 = int16_t (*)(const plg::vector&, const plg::mat4x4&, const plg::vec4&, void*, uint64_t, const plg::vector&, bool, float, const plg::vector&, uint8_t, int32_t, const plg::vec2&, uint16_t, double, const plg::vector&); - - using Func16 = void* (*)(const plg::vector&, int16_t, const plg::vector&, const plg::vec4&, const plg::mat4x4&, const plg::vec2&, const plg::vector&, const plg::vector&, const plg::string&, int64_t, const plg::vector&, const plg::vec3&, float, double, int8_t, uint16_t); - - using Func17 = void (*)(int32_t&); - - using Func18 = plg::vec2 (*)(int8_t&, int16_t&); - - using Func19 = void (*)(uint32_t&, plg::vec3&, plg::vector&); - - using Func20 = int32_t (*)(char16_t&, plg::vec4&, plg::vector&, char&); - - using Func21 = float (*)(plg::mat4x4&, plg::vector&, plg::vec2&, bool&, double&); - - using Func22 = uint64_t (*)(void*&, uint32_t&, plg::vector&, int16_t&, plg::string&, plg::vec4&); - - using Func23 = void (*)(uint64_t&, plg::vec2&, plg::vector&, char16_t&, float&, int8_t&, plg::vector&); - - using Func24 = plg::mat4x4 (*)(plg::vector&, int64_t&, plg::vector&, plg::vec4&, uint64_t&, plg::vector&, double&, plg::vector&); - - using Func25 = double (*)(int32_t&, plg::vector&, bool&, uint8_t&, plg::string&, plg::vec3&, int64_t&, plg::vec4&, uint16_t&); - - using Func26 = char (*)(char16_t&, plg::vec2&, plg::mat4x4&, plg::vector&, int16_t&, uint64_t&, uint32_t&, plg::vector&, void*&, bool&); - - using Func27 = uint8_t (*)(float&, plg::vec3&, void*&, plg::vec2&, plg::vector&, plg::mat4x4&, bool&, plg::vec4&, int8_t&, int32_t&, plg::vector&); - - using Func28 = plg::string (*)(void*&, uint16_t&, plg::vector&, plg::mat4x4&, float&, plg::vec4&, plg::string&, plg::vector&, int64_t&, bool&, plg::vec3&, plg::vector&); - - using Func29 = plg::vector (*)(plg::vec4&, int32_t&, plg::vector&, double&, bool&, int8_t&, plg::vector&, float&, plg::string&, plg::mat4x4&, uint64_t&, plg::vec3&, plg::vector&); - - using Func30 = int32_t (*)(void*&, plg::vec4&, int64_t&, plg::vector&, bool&, plg::string&, plg::vec3&, plg::vector&, float&, plg::vec2&, plg::mat4x4&, int8_t&, plg::vector&, double&); - - using Func31 = plg::vec3 (*)(char&, uint32_t&, plg::vector&, plg::vec4&, plg::string&, bool&, int64_t&, plg::vec2&, int8_t&, uint16_t&, plg::vector&, plg::mat4x4&, plg::vec3&, float&, plg::vector&); - - using Func32 = double (*)(int32_t&, uint16_t&, plg::vector&, plg::vec4&, void*&, plg::vector&, plg::mat4x4&, uint64_t&, plg::string&, int64_t&, plg::vec2&, plg::vector&, bool&, plg::vec3&, uint8_t&, plg::vector&); - - using Func33 = void (*)(plg::any&); - - using FuncEnum = plg::vector (*)(Example, plg::vector&); - - - /** - * @function ReverseReturn - * @param returnString (string) - */ - inline void ReverseReturn(const plg::string& returnString) { - using ReverseReturnFn = void (*)(const plg::string&); - static ReverseReturnFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ReverseReturn", reinterpret_cast(&__func)); - __func(returnString); - } - - /** - * @function NoParamReturnVoidCallback - */ - inline void NoParamReturnVoidCallback() { - using NoParamReturnVoidCallbackFn = void (*)(); - static NoParamReturnVoidCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnVoidCallback", reinterpret_cast(&__func)); - __func(); - } - - /** - * @function NoParamReturnBoolCallback - * @return bool - */ - inline bool NoParamReturnBoolCallback() { - using NoParamReturnBoolCallbackFn = bool (*)(); - static NoParamReturnBoolCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnBoolCallback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnChar8Callback - * @return char8 - */ - inline char NoParamReturnChar8Callback() { - using NoParamReturnChar8CallbackFn = char (*)(); - static NoParamReturnChar8CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnChar8Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnChar16Callback - * @return char16 - */ - inline char16_t NoParamReturnChar16Callback() { - using NoParamReturnChar16CallbackFn = char16_t (*)(); - static NoParamReturnChar16CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnChar16Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnInt8Callback - * @return int8 - */ - inline int8_t NoParamReturnInt8Callback() { - using NoParamReturnInt8CallbackFn = int8_t (*)(); - static NoParamReturnInt8CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnInt8Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnInt16Callback - * @return int16 - */ - inline int16_t NoParamReturnInt16Callback() { - using NoParamReturnInt16CallbackFn = int16_t (*)(); - static NoParamReturnInt16CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnInt16Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnInt32Callback - * @return int32 - */ - inline int32_t NoParamReturnInt32Callback() { - using NoParamReturnInt32CallbackFn = int32_t (*)(); - static NoParamReturnInt32CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnInt32Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnInt64Callback - * @return int64 - */ - inline int64_t NoParamReturnInt64Callback() { - using NoParamReturnInt64CallbackFn = int64_t (*)(); - static NoParamReturnInt64CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnInt64Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnUInt8Callback - * @return uint8 - */ - inline uint8_t NoParamReturnUInt8Callback() { - using NoParamReturnUInt8CallbackFn = uint8_t (*)(); - static NoParamReturnUInt8CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnUInt8Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnUInt16Callback - * @return uint16 - */ - inline uint16_t NoParamReturnUInt16Callback() { - using NoParamReturnUInt16CallbackFn = uint16_t (*)(); - static NoParamReturnUInt16CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnUInt16Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnUInt32Callback - * @return uint32 - */ - inline uint32_t NoParamReturnUInt32Callback() { - using NoParamReturnUInt32CallbackFn = uint32_t (*)(); - static NoParamReturnUInt32CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnUInt32Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnUInt64Callback - * @return uint64 - */ - inline uint64_t NoParamReturnUInt64Callback() { - using NoParamReturnUInt64CallbackFn = uint64_t (*)(); - static NoParamReturnUInt64CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnUInt64Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnPointerCallback - * @return ptr64 - */ - inline void* NoParamReturnPointerCallback() { - using NoParamReturnPointerCallbackFn = void* (*)(); - static NoParamReturnPointerCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnPointerCallback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnFloatCallback - * @return float - */ - inline float NoParamReturnFloatCallback() { - using NoParamReturnFloatCallbackFn = float (*)(); - static NoParamReturnFloatCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnFloatCallback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnDoubleCallback - * @return double - */ - inline double NoParamReturnDoubleCallback() { - using NoParamReturnDoubleCallbackFn = double (*)(); - static NoParamReturnDoubleCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnDoubleCallback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnFunctionCallback - * @return function - */ - inline NoParamReturnFunctionCallbackFunc NoParamReturnFunctionCallback() { - using NoParamReturnFunctionCallbackFn = NoParamReturnFunctionCallbackFunc (*)(); - static NoParamReturnFunctionCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnFunctionCallback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnStringCallback - * @return string - */ - inline plg::string NoParamReturnStringCallback() { - using NoParamReturnStringCallbackFn = plg::string (*)(); - static NoParamReturnStringCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnStringCallback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnAnyCallback - * @return any - */ - inline plg::any NoParamReturnAnyCallback() { - using NoParamReturnAnyCallbackFn = plg::any (*)(); - static NoParamReturnAnyCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnAnyCallback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayBoolCallback - * @return bool[] - */ - inline plg::vector NoParamReturnArrayBoolCallback() { - using NoParamReturnArrayBoolCallbackFn = plg::vector (*)(); - static NoParamReturnArrayBoolCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayBoolCallback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayChar8Callback - * @return char8[] - */ - inline plg::vector NoParamReturnArrayChar8Callback() { - using NoParamReturnArrayChar8CallbackFn = plg::vector (*)(); - static NoParamReturnArrayChar8CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayChar8Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayChar16Callback - * @return char16[] - */ - inline plg::vector NoParamReturnArrayChar16Callback() { - using NoParamReturnArrayChar16CallbackFn = plg::vector (*)(); - static NoParamReturnArrayChar16CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayChar16Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayInt8Callback - * @return int8[] - */ - inline plg::vector NoParamReturnArrayInt8Callback() { - using NoParamReturnArrayInt8CallbackFn = plg::vector (*)(); - static NoParamReturnArrayInt8CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayInt8Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayInt16Callback - * @return int16[] - */ - inline plg::vector NoParamReturnArrayInt16Callback() { - using NoParamReturnArrayInt16CallbackFn = plg::vector (*)(); - static NoParamReturnArrayInt16CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayInt16Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayInt32Callback - * @return int32[] - */ - inline plg::vector NoParamReturnArrayInt32Callback() { - using NoParamReturnArrayInt32CallbackFn = plg::vector (*)(); - static NoParamReturnArrayInt32CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayInt32Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayInt64Callback - * @return int64[] - */ - inline plg::vector NoParamReturnArrayInt64Callback() { - using NoParamReturnArrayInt64CallbackFn = plg::vector (*)(); - static NoParamReturnArrayInt64CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayInt64Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayUInt8Callback - * @return uint8[] - */ - inline plg::vector NoParamReturnArrayUInt8Callback() { - using NoParamReturnArrayUInt8CallbackFn = plg::vector (*)(); - static NoParamReturnArrayUInt8CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayUInt8Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayUInt16Callback - * @return uint16[] - */ - inline plg::vector NoParamReturnArrayUInt16Callback() { - using NoParamReturnArrayUInt16CallbackFn = plg::vector (*)(); - static NoParamReturnArrayUInt16CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayUInt16Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayUInt32Callback - * @return uint32[] - */ - inline plg::vector NoParamReturnArrayUInt32Callback() { - using NoParamReturnArrayUInt32CallbackFn = plg::vector (*)(); - static NoParamReturnArrayUInt32CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayUInt32Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayUInt64Callback - * @return uint64[] - */ - inline plg::vector NoParamReturnArrayUInt64Callback() { - using NoParamReturnArrayUInt64CallbackFn = plg::vector (*)(); - static NoParamReturnArrayUInt64CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayUInt64Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayPointerCallback - * @return ptr64[] - */ - inline plg::vector NoParamReturnArrayPointerCallback() { - using NoParamReturnArrayPointerCallbackFn = plg::vector (*)(); - static NoParamReturnArrayPointerCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayPointerCallback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayFloatCallback - * @return float[] - */ - inline plg::vector NoParamReturnArrayFloatCallback() { - using NoParamReturnArrayFloatCallbackFn = plg::vector (*)(); - static NoParamReturnArrayFloatCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayFloatCallback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayDoubleCallback - * @return double[] - */ - inline plg::vector NoParamReturnArrayDoubleCallback() { - using NoParamReturnArrayDoubleCallbackFn = plg::vector (*)(); - static NoParamReturnArrayDoubleCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayDoubleCallback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayStringCallback - * @return string[] - */ - inline plg::vector NoParamReturnArrayStringCallback() { - using NoParamReturnArrayStringCallbackFn = plg::vector (*)(); - static NoParamReturnArrayStringCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayStringCallback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayAnyCallback - * @return any[] - */ - inline plg::vector NoParamReturnArrayAnyCallback() { - using NoParamReturnArrayAnyCallbackFn = plg::vector (*)(); - static NoParamReturnArrayAnyCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayAnyCallback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayVector2Callback - * @return vec2[] - */ - inline plg::vector NoParamReturnArrayVector2Callback() { - using NoParamReturnArrayVector2CallbackFn = plg::vector (*)(); - static NoParamReturnArrayVector2CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayVector2Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayVector3Callback - * @return vec3[] - */ - inline plg::vector NoParamReturnArrayVector3Callback() { - using NoParamReturnArrayVector3CallbackFn = plg::vector (*)(); - static NoParamReturnArrayVector3CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayVector3Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayVector4Callback - * @return vec4[] - */ - inline plg::vector NoParamReturnArrayVector4Callback() { - using NoParamReturnArrayVector4CallbackFn = plg::vector (*)(); - static NoParamReturnArrayVector4CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayVector4Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnArrayMatrix4x4Callback - * @return mat4x4[] - */ - inline plg::vector NoParamReturnArrayMatrix4x4Callback() { - using NoParamReturnArrayMatrix4x4CallbackFn = plg::vector (*)(); - static NoParamReturnArrayMatrix4x4CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnArrayMatrix4x4Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnVector2Callback - * @return vec2 - */ - inline plg::vec2 NoParamReturnVector2Callback() { - using NoParamReturnVector2CallbackFn = plg::vec2 (*)(); - static NoParamReturnVector2CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnVector2Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnVector3Callback - * @return vec3 - */ - inline plg::vec3 NoParamReturnVector3Callback() { - using NoParamReturnVector3CallbackFn = plg::vec3 (*)(); - static NoParamReturnVector3CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnVector3Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnVector4Callback - * @return vec4 - */ - inline plg::vec4 NoParamReturnVector4Callback() { - using NoParamReturnVector4CallbackFn = plg::vec4 (*)(); - static NoParamReturnVector4CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnVector4Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function NoParamReturnMatrix4x4Callback - * @return mat4x4 - */ - inline plg::mat4x4 NoParamReturnMatrix4x4Callback() { - using NoParamReturnMatrix4x4CallbackFn = plg::mat4x4 (*)(); - static NoParamReturnMatrix4x4CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.NoParamReturnMatrix4x4Callback", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function Param1Callback - * @param a (int32) - */ - inline void Param1Callback(int32_t a) { - using Param1CallbackFn = void (*)(int32_t); - static Param1CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.Param1Callback", reinterpret_cast(&__func)); - __func(a); - } - - /** - * @function Param2Callback - * @param a (int32) - * @param b (float) - */ - inline void Param2Callback(int32_t a, float b) { - using Param2CallbackFn = void (*)(int32_t, float); - static Param2CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.Param2Callback", reinterpret_cast(&__func)); - __func(a, b); - } - - /** - * @function Param3Callback - * @param a (int32) - * @param b (float) - * @param c (double) - */ - inline void Param3Callback(int32_t a, float b, double c) { - using Param3CallbackFn = void (*)(int32_t, float, double); - static Param3CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.Param3Callback", reinterpret_cast(&__func)); - __func(a, b, c); - } - - /** - * @function Param4Callback - * @param a (int32) - * @param b (float) - * @param c (double) - * @param d (vec4) - */ - inline void Param4Callback(int32_t a, float b, double c, const plg::vec4& d) { - using Param4CallbackFn = void (*)(int32_t, float, double, const plg::vec4&); - static Param4CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.Param4Callback", reinterpret_cast(&__func)); - __func(a, b, c, d); - } - - /** - * @function Param5Callback - * @param a (int32) - * @param b (float) - * @param c (double) - * @param d (vec4) - * @param e (int64[]) - */ - inline void Param5Callback(int32_t a, float b, double c, const plg::vec4& d, const plg::vector& e) { - using Param5CallbackFn = void (*)(int32_t, float, double, const plg::vec4&, const plg::vector&); - static Param5CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.Param5Callback", reinterpret_cast(&__func)); - __func(a, b, c, d, e); - } - - /** - * @function Param6Callback - * @param a (int32) - * @param b (float) - * @param c (double) - * @param d (vec4) - * @param e (int64[]) - * @param f (char8) - */ - inline void Param6Callback(int32_t a, float b, double c, const plg::vec4& d, const plg::vector& e, char f) { - using Param6CallbackFn = void (*)(int32_t, float, double, const plg::vec4&, const plg::vector&, char); - static Param6CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.Param6Callback", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f); - } - - /** - * @function Param7Callback - * @param a (int32) - * @param b (float) - * @param c (double) - * @param d (vec4) - * @param e (int64[]) - * @param f (char8) - * @param g (string) - */ - inline void Param7Callback(int32_t a, float b, double c, const plg::vec4& d, const plg::vector& e, char f, const plg::string& g) { - using Param7CallbackFn = void (*)(int32_t, float, double, const plg::vec4&, const plg::vector&, char, const plg::string&); - static Param7CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.Param7Callback", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f, g); - } - - /** - * @function Param8Callback - * @param a (int32) - * @param b (float) - * @param c (double) - * @param d (vec4) - * @param e (int64[]) - * @param f (char8) - * @param g (string) - * @param h (char16) - */ - inline void Param8Callback(int32_t a, float b, double c, const plg::vec4& d, const plg::vector& e, char f, const plg::string& g, char16_t h) { - using Param8CallbackFn = void (*)(int32_t, float, double, const plg::vec4&, const plg::vector&, char, const plg::string&, char16_t); - static Param8CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.Param8Callback", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f, g, h); - } - - /** - * @function Param9Callback - * @param a (int32) - * @param b (float) - * @param c (double) - * @param d (vec4) - * @param e (int64[]) - * @param f (char8) - * @param g (string) - * @param h (char16) - * @param k (int16) - */ - inline void Param9Callback(int32_t a, float b, double c, const plg::vec4& d, const plg::vector& e, char f, const plg::string& g, char16_t h, int16_t k) { - using Param9CallbackFn = void (*)(int32_t, float, double, const plg::vec4&, const plg::vector&, char, const plg::string&, char16_t, int16_t); - static Param9CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.Param9Callback", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f, g, h, k); - } - - /** - * @function Param10Callback - * @param a (int32) - * @param b (float) - * @param c (double) - * @param d (vec4) - * @param e (int64[]) - * @param f (char8) - * @param g (string) - * @param h (char16) - * @param k (int16) - * @param l (ptr64) - */ - inline void Param10Callback(int32_t a, float b, double c, const plg::vec4& d, const plg::vector& e, char f, const plg::string& g, char16_t h, int16_t k, void* l) { - using Param10CallbackFn = void (*)(int32_t, float, double, const plg::vec4&, const plg::vector&, char, const plg::string&, char16_t, int16_t, void*); - static Param10CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.Param10Callback", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f, g, h, k, l); - } - - /** - * @function ParamRef1Callback - * @param a (int32&) - */ - inline void ParamRef1Callback(int32_t& a) { - using ParamRef1CallbackFn = void (*)(int32_t&); - static ParamRef1CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ParamRef1Callback", reinterpret_cast(&__func)); - __func(a); - } - - /** - * @function ParamRef2Callback - * @param a (int32&) - * @param b (float&) - */ - inline void ParamRef2Callback(int32_t& a, float& b) { - using ParamRef2CallbackFn = void (*)(int32_t&, float&); - static ParamRef2CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ParamRef2Callback", reinterpret_cast(&__func)); - __func(a, b); - } - - /** - * @function ParamRef3Callback - * @param a (int32&) - * @param b (float&) - * @param c (double&) - */ - inline void ParamRef3Callback(int32_t& a, float& b, double& c) { - using ParamRef3CallbackFn = void (*)(int32_t&, float&, double&); - static ParamRef3CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ParamRef3Callback", reinterpret_cast(&__func)); - __func(a, b, c); - } - - /** - * @function ParamRef4Callback - * @param a (int32&) - * @param b (float&) - * @param c (double&) - * @param d (vec4&) - */ - inline void ParamRef4Callback(int32_t& a, float& b, double& c, plg::vec4& d) { - using ParamRef4CallbackFn = void (*)(int32_t&, float&, double&, plg::vec4&); - static ParamRef4CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ParamRef4Callback", reinterpret_cast(&__func)); - __func(a, b, c, d); - } - - /** - * @function ParamRef5Callback - * @param a (int32&) - * @param b (float&) - * @param c (double&) - * @param d (vec4&) - * @param e (int64[]&) - */ - inline void ParamRef5Callback(int32_t& a, float& b, double& c, plg::vec4& d, plg::vector& e) { - using ParamRef5CallbackFn = void (*)(int32_t&, float&, double&, plg::vec4&, plg::vector&); - static ParamRef5CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ParamRef5Callback", reinterpret_cast(&__func)); - __func(a, b, c, d, e); - } - - /** - * @function ParamRef6Callback - * @param a (int32&) - * @param b (float&) - * @param c (double&) - * @param d (vec4&) - * @param e (int64[]&) - * @param f (char8&) - */ - inline void ParamRef6Callback(int32_t& a, float& b, double& c, plg::vec4& d, plg::vector& e, char& f) { - using ParamRef6CallbackFn = void (*)(int32_t&, float&, double&, plg::vec4&, plg::vector&, char&); - static ParamRef6CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ParamRef6Callback", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f); - } - - /** - * @function ParamRef7Callback - * @param a (int32&) - * @param b (float&) - * @param c (double&) - * @param d (vec4&) - * @param e (int64[]&) - * @param f (char8&) - * @param g (string&) - */ - inline void ParamRef7Callback(int32_t& a, float& b, double& c, plg::vec4& d, plg::vector& e, char& f, plg::string& g) { - using ParamRef7CallbackFn = void (*)(int32_t&, float&, double&, plg::vec4&, plg::vector&, char&, plg::string&); - static ParamRef7CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ParamRef7Callback", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f, g); - } - - /** - * @function ParamRef8Callback - * @param a (int32&) - * @param b (float&) - * @param c (double&) - * @param d (vec4&) - * @param e (int64[]&) - * @param f (char8&) - * @param g (string&) - * @param h (char16&) - */ - inline void ParamRef8Callback(int32_t& a, float& b, double& c, plg::vec4& d, plg::vector& e, char& f, plg::string& g, char16_t& h) { - using ParamRef8CallbackFn = void (*)(int32_t&, float&, double&, plg::vec4&, plg::vector&, char&, plg::string&, char16_t&); - static ParamRef8CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ParamRef8Callback", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f, g, h); - } - - /** - * @function ParamRef9Callback - * @param a (int32&) - * @param b (float&) - * @param c (double&) - * @param d (vec4&) - * @param e (int64[]&) - * @param f (char8&) - * @param g (string&) - * @param h (char16&) - * @param k (int16&) - */ - inline void ParamRef9Callback(int32_t& a, float& b, double& c, plg::vec4& d, plg::vector& e, char& f, plg::string& g, char16_t& h, int16_t& k) { - using ParamRef9CallbackFn = void (*)(int32_t&, float&, double&, plg::vec4&, plg::vector&, char&, plg::string&, char16_t&, int16_t&); - static ParamRef9CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ParamRef9Callback", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f, g, h, k); - } - - /** - * @function ParamRef10Callback - * @param a (int32&) - * @param b (float&) - * @param c (double&) - * @param d (vec4&) - * @param e (int64[]&) - * @param f (char8&) - * @param g (string&) - * @param h (char16&) - * @param k (int16&) - * @param l (ptr64&) - */ - inline void ParamRef10Callback(int32_t& a, float& b, double& c, plg::vec4& d, plg::vector& e, char& f, plg::string& g, char16_t& h, int16_t& k, void*& l) { - using ParamRef10CallbackFn = void (*)(int32_t&, float&, double&, plg::vec4&, plg::vector&, char&, plg::string&, char16_t&, int16_t&, void*&); - static ParamRef10CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ParamRef10Callback", reinterpret_cast(&__func)); - __func(a, b, c, d, e, f, g, h, k, l); - } - - /** - * @function ParamRefVectorsCallback - * @param p1 (bool[]&) - * @param p2 (char8[]&) - * @param p3 (char16[]&) - * @param p4 (int8[]&) - * @param p5 (int16[]&) - * @param p6 (int32[]&) - * @param p7 (int64[]&) - * @param p8 (uint8[]&) - * @param p9 (uint16[]&) - * @param p10 (uint32[]&) - * @param p11 (uint64[]&) - * @param p12 (ptr64[]&) - * @param p13 (float[]&) - * @param p14 (double[]&) - * @param p15 (string[]&) - */ - inline void ParamRefVectorsCallback(plg::vector& p1, plg::vector& p2, plg::vector& p3, plg::vector& p4, plg::vector& p5, plg::vector& p6, plg::vector& p7, plg::vector& p8, plg::vector& p9, plg::vector& p10, plg::vector& p11, plg::vector& p12, plg::vector& p13, plg::vector& p14, plg::vector& p15) { - using ParamRefVectorsCallbackFn = void (*)(plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&, plg::vector&); - static ParamRefVectorsCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ParamRefVectorsCallback", reinterpret_cast(&__func)); - __func(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); - } - - /** - * @function ParamAllPrimitivesCallback - * @param p1 (bool) - * @param p2 (char8) - * @param p3 (char16) - * @param p4 (int8) - * @param p5 (int16) - * @param p6 (int32) - * @param p7 (int64) - * @param p8 (uint8) - * @param p9 (uint16) - * @param p10 (uint32) - * @param p11 (uint64) - * @param p12 (ptr64) - * @param p13 (float) - * @param p14 (double) - * @return int64 - */ - inline int64_t ParamAllPrimitivesCallback(bool p1, char p2, char16_t p3, int8_t p4, int16_t p5, int32_t p6, int64_t p7, uint8_t p8, uint16_t p9, uint32_t p10, uint64_t p11, void* p12, float p13, double p14) { - using ParamAllPrimitivesCallbackFn = int64_t (*)(bool, char, char16_t, int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t, uint32_t, uint64_t, void*, float, double); - static ParamAllPrimitivesCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ParamAllPrimitivesCallback", reinterpret_cast(&__func)); - return __func(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); - } - - /** - * @function ParamEnumCallback - * @param p1 (int32) - * @param p2 (int32[]) - * @return int32 - */ - inline int32_t ParamEnumCallback(Example p1, plg::vector p2) { - using ParamEnumCallbackFn = int32_t (*)(Example, plg::vector); - static ParamEnumCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ParamEnumCallback", reinterpret_cast(&__func)); - return __func(p1, p2); - } - - /** - * @function ParamEnumRefCallback - * @param p1 (int32&) - * @param p2 (int32[]&) - * @return int32 - */ - inline int32_t ParamEnumRefCallback(Example& p1, plg::vector p2) { - using ParamEnumRefCallbackFn = int32_t (*)(Example&, plg::vector); - static ParamEnumRefCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ParamEnumRefCallback", reinterpret_cast(&__func)); - return __func(p1, p2); - } - - /** - * @function ParamVariantCallback - * @param p1 (any) - * @param p2 (any[]) - */ - inline void ParamVariantCallback(const plg::any& p1, const plg::vector& p2) { - using ParamVariantCallbackFn = void (*)(const plg::any&, const plg::vector&); - static ParamVariantCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ParamVariantCallback", reinterpret_cast(&__func)); - __func(p1, p2); - } - - /** - * @function ParamVariantRefCallback - * @param p1 (any&) - * @param p2 (any[]&) - */ - inline void ParamVariantRefCallback(plg::any& p1, plg::vector& p2) { - using ParamVariantRefCallbackFn = void (*)(plg::any&, plg::vector&); - static ParamVariantRefCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ParamVariantRefCallback", reinterpret_cast(&__func)); - __func(p1, p2); - } - - /** - * @function CallFuncVoidCallback - * @param func (function) - */ - inline void CallFuncVoidCallback(FuncVoid func) { - using CallFuncVoidCallbackFn = void (*)(FuncVoid); - static CallFuncVoidCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncVoidCallback", reinterpret_cast(&__func)); - __func(func); - } - - /** - * @function CallFuncBoolCallback - * @param func (function) - * @return bool - */ - inline bool CallFuncBoolCallback(FuncBool func) { - using CallFuncBoolCallbackFn = bool (*)(FuncBool); - static CallFuncBoolCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncBoolCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncChar8Callback - * @param func (function) - * @return char8 - */ - inline char CallFuncChar8Callback(FuncChar8 func) { - using CallFuncChar8CallbackFn = char (*)(FuncChar8); - static CallFuncChar8CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncChar8Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncChar16Callback - * @param func (function) - * @return char16 - */ - inline char16_t CallFuncChar16Callback(FuncChar16 func) { - using CallFuncChar16CallbackFn = char16_t (*)(FuncChar16); - static CallFuncChar16CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncChar16Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncInt8Callback - * @param func (function) - * @return int8 - */ - inline int8_t CallFuncInt8Callback(FuncInt8 func) { - using CallFuncInt8CallbackFn = int8_t (*)(FuncInt8); - static CallFuncInt8CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncInt8Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncInt16Callback - * @param func (function) - * @return int16 - */ - inline int16_t CallFuncInt16Callback(FuncInt16 func) { - using CallFuncInt16CallbackFn = int16_t (*)(FuncInt16); - static CallFuncInt16CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncInt16Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncInt32Callback - * @param func (function) - * @return int32 - */ - inline int32_t CallFuncInt32Callback(FuncInt32 func) { - using CallFuncInt32CallbackFn = int32_t (*)(FuncInt32); - static CallFuncInt32CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncInt32Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncInt64Callback - * @param func (function) - * @return int64 - */ - inline int64_t CallFuncInt64Callback(FuncInt64 func) { - using CallFuncInt64CallbackFn = int64_t (*)(FuncInt64); - static CallFuncInt64CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncInt64Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncUInt8Callback - * @param func (function) - * @return uint8 - */ - inline uint8_t CallFuncUInt8Callback(FuncUInt8 func) { - using CallFuncUInt8CallbackFn = uint8_t (*)(FuncUInt8); - static CallFuncUInt8CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncUInt8Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncUInt16Callback - * @param func (function) - * @return uint16 - */ - inline uint16_t CallFuncUInt16Callback(FuncUInt16 func) { - using CallFuncUInt16CallbackFn = uint16_t (*)(FuncUInt16); - static CallFuncUInt16CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncUInt16Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncUInt32Callback - * @param func (function) - * @return uint32 - */ - inline uint32_t CallFuncUInt32Callback(FuncUInt32 func) { - using CallFuncUInt32CallbackFn = uint32_t (*)(FuncUInt32); - static CallFuncUInt32CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncUInt32Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncUInt64Callback - * @param func (function) - * @return uint64 - */ - inline uint64_t CallFuncUInt64Callback(FuncUInt64 func) { - using CallFuncUInt64CallbackFn = uint64_t (*)(FuncUInt64); - static CallFuncUInt64CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncUInt64Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncPtrCallback - * @param func (function) - * @return ptr64 - */ - inline void* CallFuncPtrCallback(FuncPtr func) { - using CallFuncPtrCallbackFn = void* (*)(FuncPtr); - static CallFuncPtrCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncPtrCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncFloatCallback - * @param func (function) - * @return float - */ - inline float CallFuncFloatCallback(FuncFloat func) { - using CallFuncFloatCallbackFn = float (*)(FuncFloat); - static CallFuncFloatCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncFloatCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncDoubleCallback - * @param func (function) - * @return double - */ - inline double CallFuncDoubleCallback(FuncDouble func) { - using CallFuncDoubleCallbackFn = double (*)(FuncDouble); - static CallFuncDoubleCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncDoubleCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncStringCallback - * @param func (function) - * @return string - */ - inline plg::string CallFuncStringCallback(FuncString func) { - using CallFuncStringCallbackFn = plg::string (*)(FuncString); - static CallFuncStringCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncStringCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncAnyCallback - * @param func (function) - * @return any - */ - inline plg::any CallFuncAnyCallback(FuncAny func) { - using CallFuncAnyCallbackFn = plg::any (*)(FuncAny); - static CallFuncAnyCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncAnyCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncFunctionCallback - * @param func (function) - * @return ptr64 - */ - inline void* CallFuncFunctionCallback(FuncFunction func) { - using CallFuncFunctionCallbackFn = void* (*)(FuncFunction); - static CallFuncFunctionCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncFunctionCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncBoolVectorCallback - * @param func (function) - * @return bool[] - */ - inline plg::vector CallFuncBoolVectorCallback(FuncBoolVector func) { - using CallFuncBoolVectorCallbackFn = plg::vector (*)(FuncBoolVector); - static CallFuncBoolVectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncBoolVectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncChar8VectorCallback - * @param func (function) - * @return char8[] - */ - inline plg::vector CallFuncChar8VectorCallback(FuncChar8Vector func) { - using CallFuncChar8VectorCallbackFn = plg::vector (*)(FuncChar8Vector); - static CallFuncChar8VectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncChar8VectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncChar16VectorCallback - * @param func (function) - * @return char16[] - */ - inline plg::vector CallFuncChar16VectorCallback(FuncChar16Vector func) { - using CallFuncChar16VectorCallbackFn = plg::vector (*)(FuncChar16Vector); - static CallFuncChar16VectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncChar16VectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncInt8VectorCallback - * @param func (function) - * @return int8[] - */ - inline plg::vector CallFuncInt8VectorCallback(FuncInt8Vector func) { - using CallFuncInt8VectorCallbackFn = plg::vector (*)(FuncInt8Vector); - static CallFuncInt8VectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncInt8VectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncInt16VectorCallback - * @param func (function) - * @return int16[] - */ - inline plg::vector CallFuncInt16VectorCallback(FuncInt16Vector func) { - using CallFuncInt16VectorCallbackFn = plg::vector (*)(FuncInt16Vector); - static CallFuncInt16VectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncInt16VectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncInt32VectorCallback - * @param func (function) - * @return int32[] - */ - inline plg::vector CallFuncInt32VectorCallback(FuncInt32Vector func) { - using CallFuncInt32VectorCallbackFn = plg::vector (*)(FuncInt32Vector); - static CallFuncInt32VectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncInt32VectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncInt64VectorCallback - * @param func (function) - * @return int64[] - */ - inline plg::vector CallFuncInt64VectorCallback(FuncInt64Vector func) { - using CallFuncInt64VectorCallbackFn = plg::vector (*)(FuncInt64Vector); - static CallFuncInt64VectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncInt64VectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncUInt8VectorCallback - * @param func (function) - * @return uint8[] - */ - inline plg::vector CallFuncUInt8VectorCallback(FuncUInt8Vector func) { - using CallFuncUInt8VectorCallbackFn = plg::vector (*)(FuncUInt8Vector); - static CallFuncUInt8VectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncUInt8VectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncUInt16VectorCallback - * @param func (function) - * @return uint16[] - */ - inline plg::vector CallFuncUInt16VectorCallback(FuncUInt16Vector func) { - using CallFuncUInt16VectorCallbackFn = plg::vector (*)(FuncUInt16Vector); - static CallFuncUInt16VectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncUInt16VectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncUInt32VectorCallback - * @param func (function) - * @return uint32[] - */ - inline plg::vector CallFuncUInt32VectorCallback(FuncUInt32Vector func) { - using CallFuncUInt32VectorCallbackFn = plg::vector (*)(FuncUInt32Vector); - static CallFuncUInt32VectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncUInt32VectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncUInt64VectorCallback - * @param func (function) - * @return uint64[] - */ - inline plg::vector CallFuncUInt64VectorCallback(FuncUInt64Vector func) { - using CallFuncUInt64VectorCallbackFn = plg::vector (*)(FuncUInt64Vector); - static CallFuncUInt64VectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncUInt64VectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncPtrVectorCallback - * @param func (function) - * @return ptr64[] - */ - inline plg::vector CallFuncPtrVectorCallback(FuncPtrVector func) { - using CallFuncPtrVectorCallbackFn = plg::vector (*)(FuncPtrVector); - static CallFuncPtrVectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncPtrVectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncFloatVectorCallback - * @param func (function) - * @return float[] - */ - inline plg::vector CallFuncFloatVectorCallback(FuncFloatVector func) { - using CallFuncFloatVectorCallbackFn = plg::vector (*)(FuncFloatVector); - static CallFuncFloatVectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncFloatVectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncDoubleVectorCallback - * @param func (function) - * @return double[] - */ - inline plg::vector CallFuncDoubleVectorCallback(FuncDoubleVector func) { - using CallFuncDoubleVectorCallbackFn = plg::vector (*)(FuncDoubleVector); - static CallFuncDoubleVectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncDoubleVectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncStringVectorCallback - * @param func (function) - * @return string[] - */ - inline plg::vector CallFuncStringVectorCallback(FuncStringVector func) { - using CallFuncStringVectorCallbackFn = plg::vector (*)(FuncStringVector); - static CallFuncStringVectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncStringVectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncAnyVectorCallback - * @param func (function) - * @return any[] - */ - inline plg::vector CallFuncAnyVectorCallback(FuncAnyVector func) { - using CallFuncAnyVectorCallbackFn = plg::vector (*)(FuncAnyVector); - static CallFuncAnyVectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncAnyVectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncVec2VectorCallback - * @param func (function) - * @return vec2[] - */ - inline plg::vector CallFuncVec2VectorCallback(FuncVec2Vector func) { - using CallFuncVec2VectorCallbackFn = plg::vector (*)(FuncVec2Vector); - static CallFuncVec2VectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncVec2VectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncVec3VectorCallback - * @param func (function) - * @return vec3[] - */ - inline plg::vector CallFuncVec3VectorCallback(FuncVec3Vector func) { - using CallFuncVec3VectorCallbackFn = plg::vector (*)(FuncVec3Vector); - static CallFuncVec3VectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncVec3VectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncVec4VectorCallback - * @param func (function) - * @return vec4[] - */ - inline plg::vector CallFuncVec4VectorCallback(FuncVec4Vector func) { - using CallFuncVec4VectorCallbackFn = plg::vector (*)(FuncVec4Vector); - static CallFuncVec4VectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncVec4VectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncMat4x4VectorCallback - * @param func (function) - * @return mat4x4[] - */ - inline plg::vector CallFuncMat4x4VectorCallback(FuncMat4x4Vector func) { - using CallFuncMat4x4VectorCallbackFn = plg::vector (*)(FuncMat4x4Vector); - static CallFuncMat4x4VectorCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncMat4x4VectorCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncVec2Callback - * @param func (function) - * @return vec2 - */ - inline plg::vec2 CallFuncVec2Callback(FuncVec2 func) { - using CallFuncVec2CallbackFn = plg::vec2 (*)(FuncVec2); - static CallFuncVec2CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncVec2Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncVec3Callback - * @param func (function) - * @return vec3 - */ - inline plg::vec3 CallFuncVec3Callback(FuncVec3 func) { - using CallFuncVec3CallbackFn = plg::vec3 (*)(FuncVec3); - static CallFuncVec3CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncVec3Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncVec4Callback - * @param func (function) - * @return vec4 - */ - inline plg::vec4 CallFuncVec4Callback(FuncVec4 func) { - using CallFuncVec4CallbackFn = plg::vec4 (*)(FuncVec4); - static CallFuncVec4CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncVec4Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncMat4x4Callback - * @param func (function) - * @return mat4x4 - */ - inline plg::mat4x4 CallFuncMat4x4Callback(FuncMat4x4 func) { - using CallFuncMat4x4CallbackFn = plg::mat4x4 (*)(FuncMat4x4); - static CallFuncMat4x4CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncMat4x4Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc1Callback - * @param func (function) - * @return int32 - */ - inline int32_t CallFunc1Callback(Func1 func) { - using CallFunc1CallbackFn = int32_t (*)(Func1); - static CallFunc1CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc1Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc2Callback - * @param func (function) - * @return char8 - */ - inline char CallFunc2Callback(Func2 func) { - using CallFunc2CallbackFn = char (*)(Func2); - static CallFunc2CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc2Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc3Callback - * @param func (function) - */ - inline void CallFunc3Callback(Func3 func) { - using CallFunc3CallbackFn = void (*)(Func3); - static CallFunc3CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc3Callback", reinterpret_cast(&__func)); - __func(func); - } - - /** - * @function CallFunc4Callback - * @param func (function) - * @return vec4 - */ - inline plg::vec4 CallFunc4Callback(Func4 func) { - using CallFunc4CallbackFn = plg::vec4 (*)(Func4); - static CallFunc4CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc4Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc5Callback - * @param func (function) - * @return bool - */ - inline bool CallFunc5Callback(Func5 func) { - using CallFunc5CallbackFn = bool (*)(Func5); - static CallFunc5CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc5Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc6Callback - * @param func (function) - * @return int64 - */ - inline int64_t CallFunc6Callback(Func6 func) { - using CallFunc6CallbackFn = int64_t (*)(Func6); - static CallFunc6CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc6Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc7Callback - * @param func (function) - * @return double - */ - inline double CallFunc7Callback(Func7 func) { - using CallFunc7CallbackFn = double (*)(Func7); - static CallFunc7CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc7Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc8Callback - * @param func (function) - * @return mat4x4 - */ - inline plg::mat4x4 CallFunc8Callback(Func8 func) { - using CallFunc8CallbackFn = plg::mat4x4 (*)(Func8); - static CallFunc8CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc8Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc9Callback - * @param func (function) - */ - inline void CallFunc9Callback(Func9 func) { - using CallFunc9CallbackFn = void (*)(Func9); - static CallFunc9CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc9Callback", reinterpret_cast(&__func)); - __func(func); - } - - /** - * @function CallFunc10Callback - * @param func (function) - * @return uint32 - */ - inline uint32_t CallFunc10Callback(Func10 func) { - using CallFunc10CallbackFn = uint32_t (*)(Func10); - static CallFunc10CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc10Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc11Callback - * @param func (function) - * @return ptr64 - */ - inline void* CallFunc11Callback(Func11 func) { - using CallFunc11CallbackFn = void* (*)(Func11); - static CallFunc11CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc11Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc12Callback - * @param func (function) - * @return bool - */ - inline bool CallFunc12Callback(Func12 func) { - using CallFunc12CallbackFn = bool (*)(Func12); - static CallFunc12CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc12Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc13Callback - * @param func (function) - * @return string - */ - inline plg::string CallFunc13Callback(Func13 func) { - using CallFunc13CallbackFn = plg::string (*)(Func13); - static CallFunc13CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc13Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc14Callback - * @param func (function) - * @return string[] - */ - inline plg::vector CallFunc14Callback(Func14 func) { - using CallFunc14CallbackFn = plg::vector (*)(Func14); - static CallFunc14CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc14Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc15Callback - * @param func (function) - * @return int16 - */ - inline int16_t CallFunc15Callback(Func15 func) { - using CallFunc15CallbackFn = int16_t (*)(Func15); - static CallFunc15CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc15Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc16Callback - * @param func (function) - * @return ptr64 - */ - inline void* CallFunc16Callback(Func16 func) { - using CallFunc16CallbackFn = void* (*)(Func16); - static CallFunc16CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc16Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc17Callback - * @param func (function) - * @return string - */ - inline plg::string CallFunc17Callback(Func17 func) { - using CallFunc17CallbackFn = plg::string (*)(Func17); - static CallFunc17CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc17Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc18Callback - * @param func (function) - * @return string - */ - inline plg::string CallFunc18Callback(Func18 func) { - using CallFunc18CallbackFn = plg::string (*)(Func18); - static CallFunc18CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc18Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc19Callback - * @param func (function) - * @return string - */ - inline plg::string CallFunc19Callback(Func19 func) { - using CallFunc19CallbackFn = plg::string (*)(Func19); - static CallFunc19CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc19Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc20Callback - * @param func (function) - * @return string - */ - inline plg::string CallFunc20Callback(Func20 func) { - using CallFunc20CallbackFn = plg::string (*)(Func20); - static CallFunc20CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc20Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc21Callback - * @param func (function) - * @return string - */ - inline plg::string CallFunc21Callback(Func21 func) { - using CallFunc21CallbackFn = plg::string (*)(Func21); - static CallFunc21CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc21Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc22Callback - * @param func (function) - * @return string - */ - inline plg::string CallFunc22Callback(Func22 func) { - using CallFunc22CallbackFn = plg::string (*)(Func22); - static CallFunc22CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc22Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc23Callback - * @param func (function) - * @return string - */ - inline plg::string CallFunc23Callback(Func23 func) { - using CallFunc23CallbackFn = plg::string (*)(Func23); - static CallFunc23CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc23Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc24Callback - * @param func (function) - * @return string - */ - inline plg::string CallFunc24Callback(Func24 func) { - using CallFunc24CallbackFn = plg::string (*)(Func24); - static CallFunc24CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc24Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc25Callback - * @param func (function) - * @return string - */ - inline plg::string CallFunc25Callback(Func25 func) { - using CallFunc25CallbackFn = plg::string (*)(Func25); - static CallFunc25CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc25Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc26Callback - * @param func (function) - * @return string - */ - inline plg::string CallFunc26Callback(Func26 func) { - using CallFunc26CallbackFn = plg::string (*)(Func26); - static CallFunc26CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc26Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc27Callback - * @param func (function) - * @return string - */ - inline plg::string CallFunc27Callback(Func27 func) { - using CallFunc27CallbackFn = plg::string (*)(Func27); - static CallFunc27CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc27Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc28Callback - * @param func (function) - * @return string - */ - inline plg::string CallFunc28Callback(Func28 func) { - using CallFunc28CallbackFn = plg::string (*)(Func28); - static CallFunc28CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc28Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc29Callback - * @param func (function) - * @return string - */ - inline plg::string CallFunc29Callback(Func29 func) { - using CallFunc29CallbackFn = plg::string (*)(Func29); - static CallFunc29CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc29Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc30Callback - * @param func (function) - * @return string - */ - inline plg::string CallFunc30Callback(Func30 func) { - using CallFunc30CallbackFn = plg::string (*)(Func30); - static CallFunc30CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc30Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc31Callback - * @param func (function) - * @return string - */ - inline plg::string CallFunc31Callback(Func31 func) { - using CallFunc31CallbackFn = plg::string (*)(Func31); - static CallFunc31CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc31Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc32Callback - * @param func (function) - * @return string - */ - inline plg::string CallFunc32Callback(Func32 func) { - using CallFunc32CallbackFn = plg::string (*)(Func32); - static CallFunc32CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc32Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFunc33Callback - * @param func (function) - * @return string - */ - inline plg::string CallFunc33Callback(Func33 func) { - using CallFunc33CallbackFn = plg::string (*)(Func33); - static CallFunc33CallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFunc33Callback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function CallFuncEnumCallback - * @param func (function) - * @return string - */ - inline plg::string CallFuncEnumCallback(FuncEnum func) { - using CallFuncEnumCallbackFn = plg::string (*)(FuncEnum); - static CallFuncEnumCallbackFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CallFuncEnumCallback", reinterpret_cast(&__func)); - return __func(func); - } - - /** - * @function ResourceHandleCreate - * @param id (int32) - * @param name (string) - * @return ptr64 - */ - inline void* ResourceHandleCreate(int32_t id, const plg::string& name) { - using ResourceHandleCreateFn = void* (*)(int32_t, const plg::string&); - static ResourceHandleCreateFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ResourceHandleCreate", reinterpret_cast(&__func)); - return __func(id, name); - } - - /** - * @function ResourceHandleCreateDefault - * @return ptr64 - */ - inline void* ResourceHandleCreateDefault() { - using ResourceHandleCreateDefaultFn = void* (*)(); - static ResourceHandleCreateDefaultFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ResourceHandleCreateDefault", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function ResourceHandleDestroy - * @param handle (ptr64) - */ - inline void ResourceHandleDestroy(void* handle) { - using ResourceHandleDestroyFn = void (*)(void*); - static ResourceHandleDestroyFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ResourceHandleDestroy", reinterpret_cast(&__func)); - __func(handle); - } - - /** - * @function ResourceHandleGetId - * @param handle (ptr64) - * @return int32 - */ - inline int32_t ResourceHandleGetId(void* handle) { - using ResourceHandleGetIdFn = int32_t (*)(void*); - static ResourceHandleGetIdFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ResourceHandleGetId", reinterpret_cast(&__func)); - return __func(handle); - } - - /** - * @function ResourceHandleGetName - * @param handle (ptr64) - * @return string - */ - inline plg::string ResourceHandleGetName(void* handle) { - using ResourceHandleGetNameFn = plg::string (*)(void*); - static ResourceHandleGetNameFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ResourceHandleGetName", reinterpret_cast(&__func)); - return __func(handle); - } - - /** - * @function ResourceHandleSetName - * @param handle (ptr64) - * @param name (string) - */ - inline void ResourceHandleSetName(void* handle, const plg::string& name) { - using ResourceHandleSetNameFn = void (*)(void*, const plg::string&); - static ResourceHandleSetNameFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ResourceHandleSetName", reinterpret_cast(&__func)); - __func(handle, name); - } - - /** - * @function ResourceHandleIncrementCounter - * @param handle (ptr64) - */ - inline void ResourceHandleIncrementCounter(void* handle) { - using ResourceHandleIncrementCounterFn = void (*)(void*); - static ResourceHandleIncrementCounterFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ResourceHandleIncrementCounter", reinterpret_cast(&__func)); - __func(handle); - } - - /** - * @function ResourceHandleGetCounter - * @param handle (ptr64) - * @return int32 - */ - inline int32_t ResourceHandleGetCounter(void* handle) { - using ResourceHandleGetCounterFn = int32_t (*)(void*); - static ResourceHandleGetCounterFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ResourceHandleGetCounter", reinterpret_cast(&__func)); - return __func(handle); - } - - /** - * @function ResourceHandleAddData - * @param handle (ptr64) - * @param value (float) - */ - inline void ResourceHandleAddData(void* handle, float value) { - using ResourceHandleAddDataFn = void (*)(void*, float); - static ResourceHandleAddDataFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ResourceHandleAddData", reinterpret_cast(&__func)); - __func(handle, value); - } - - /** - * @function ResourceHandleGetData - * @param handle (ptr64) - * @return float[] - */ - inline plg::vector ResourceHandleGetData(void* handle) { - using ResourceHandleGetDataFn = plg::vector (*)(void*); - static ResourceHandleGetDataFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ResourceHandleGetData", reinterpret_cast(&__func)); - return __func(handle); - } - - /** - * @function ResourceHandleGetAliveCount - * @return int32 - */ - inline int32_t ResourceHandleGetAliveCount() { - using ResourceHandleGetAliveCountFn = int32_t (*)(); - static ResourceHandleGetAliveCountFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ResourceHandleGetAliveCount", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function ResourceHandleGetTotalCreated - * @return int32 - */ - inline int32_t ResourceHandleGetTotalCreated() { - using ResourceHandleGetTotalCreatedFn = int32_t (*)(); - static ResourceHandleGetTotalCreatedFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ResourceHandleGetTotalCreated", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function ResourceHandleGetTotalDestroyed - * @return int32 - */ - inline int32_t ResourceHandleGetTotalDestroyed() { - using ResourceHandleGetTotalDestroyedFn = int32_t (*)(); - static ResourceHandleGetTotalDestroyedFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.ResourceHandleGetTotalDestroyed", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function CounterCreate - * @param initialValue (int64) - * @return ptr64 - */ - inline void* CounterCreate(int64_t initialValue) { - using CounterCreateFn = void* (*)(int64_t); - static CounterCreateFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CounterCreate", reinterpret_cast(&__func)); - return __func(initialValue); - } - - /** - * @function CounterCreateZero - * @return ptr64 - */ - inline void* CounterCreateZero() { - using CounterCreateZeroFn = void* (*)(); - static CounterCreateZeroFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CounterCreateZero", reinterpret_cast(&__func)); - return __func(); - } - - /** - * @function CounterGetValue - * @param counter (ptr64) - * @return int64 - */ - inline int64_t CounterGetValue(void* counter) { - using CounterGetValueFn = int64_t (*)(void*); - static CounterGetValueFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CounterGetValue", reinterpret_cast(&__func)); - return __func(counter); - } - - /** - * @function CounterSetValue - * @param counter (ptr64) - * @param value (int64) - */ - inline void CounterSetValue(void* counter, int64_t value) { - using CounterSetValueFn = void (*)(void*, int64_t); - static CounterSetValueFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CounterSetValue", reinterpret_cast(&__func)); - __func(counter, value); - } - - /** - * @function CounterIncrement - * @param counter (ptr64) - */ - inline void CounterIncrement(void* counter) { - using CounterIncrementFn = void (*)(void*); - static CounterIncrementFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CounterIncrement", reinterpret_cast(&__func)); - __func(counter); - } - - /** - * @function CounterDecrement - * @param counter (ptr64) - */ - inline void CounterDecrement(void* counter) { - using CounterDecrementFn = void (*)(void*); - static CounterDecrementFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CounterDecrement", reinterpret_cast(&__func)); - __func(counter); - } - - /** - * @function CounterAdd - * @param counter (ptr64) - * @param amount (int64) - */ - inline void CounterAdd(void* counter, int64_t amount) { - using CounterAddFn = void (*)(void*, int64_t); - static CounterAddFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CounterAdd", reinterpret_cast(&__func)); - __func(counter, amount); - } - - /** - * @function CounterReset - * @param counter (ptr64) - */ - inline void CounterReset(void* counter) { - using CounterResetFn = void (*)(void*); - static CounterResetFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CounterReset", reinterpret_cast(&__func)); - __func(counter); - } - - /** - * @function CounterIsPositive - * @param counter (ptr64) - * @return bool - */ - inline bool CounterIsPositive(void* counter) { - using CounterIsPositiveFn = bool (*)(void*); - static CounterIsPositiveFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CounterIsPositive", reinterpret_cast(&__func)); - return __func(counter); - } - - /** - * @function CounterCompare - * @param value1 (int64) - * @param value2 (int64) - * @return int32 - */ - inline int32_t CounterCompare(int64_t value1, int64_t value2) { - using CounterCompareFn = int32_t (*)(int64_t, int64_t); - static CounterCompareFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CounterCompare", reinterpret_cast(&__func)); - return __func(value1, value2); - } - - /** - * @function CounterSum - * @param values (int64[]) - * @return int64 - */ - inline int64_t CounterSum(const plg::vector& values) { - using CounterSumFn = int64_t (*)(const plg::vector&); - static CounterSumFn __func = nullptr; - if (__func == nullptr) plg::GetMethodPtr2("cross_call_master.CounterSum", reinterpret_cast(&__func)); - return __func(values); - } - - enum class Ownership : bool { Borrowed, Owned }; - - /** - * @brief RAII wrapper for ResourceHandle pointer - */ - class ResourceHandle final { - public: - //ResourceHandle() = default; - - /** - * @param id (int32) - * @param name (string) - */ - explicit ResourceHandle(int32_t id, const plg::string& name) - : ResourceHandle(ResourceHandleCreate(id, name), Ownership::Owned) {} - - /** - */ - explicit ResourceHandle() - : ResourceHandle(ResourceHandleCreateDefault(), Ownership::Owned) {} - - ~ResourceHandle() { - destroy(); - } - - ResourceHandle(const ResourceHandle&) = delete; - ResourceHandle& operator=(const ResourceHandle&) = delete; - - ResourceHandle(ResourceHandle&& other) noexcept - : _handle(other._handle) - , _ownership(other._ownership) { - other.nullify(); - } - - ResourceHandle& operator=(ResourceHandle&& other) noexcept { - if (this != &other) { - destroy(); - _handle = other._handle; - _ownership = other._ownership; - other.nullify(); - } - return *this; - } - - ResourceHandle(void* handle, Ownership ownership) : _handle(handle), _ownership(ownership) {} - - [[nodiscard]] auto get() const noexcept { return _handle; } - - [[nodiscard]] auto release() noexcept { - auto handle = _handle; - nullify(); - return handle; - } - - void reset() noexcept { - destroy(); - nullify(); - } - - void swap(ResourceHandle& other) noexcept { - using std::swap; - swap(_handle, other._handle); - swap(_ownership, other._ownership); - } - - friend void swap(ResourceHandle& lhs, ResourceHandle& rhs) noexcept { lhs.swap(rhs); } - - explicit operator bool() const noexcept { return _handle != nullptr; } - [[nodiscard]] auto operator<=>(const ResourceHandle& other) const noexcept { return _handle <=> other._handle; } - [[nodiscard]] bool operator==(const ResourceHandle& other) const noexcept { return _handle == other._handle; } - - /** - * @return int32 - */ - int32_t GetId() { - if (_handle == nullptr) throw std::runtime_error("ResourceHandle: Empty handle"); - return ResourceHandleGetId(_handle); - } - - /** - * @return string - */ - plg::string GetName() { - if (_handle == nullptr) throw std::runtime_error("ResourceHandle: Empty handle"); - return ResourceHandleGetName(_handle); - } - - /** - * @param name (string) - */ - void SetName(const plg::string& name) { - if (_handle == nullptr) throw std::runtime_error("ResourceHandle: Empty handle"); - ResourceHandleSetName(_handle, name); - } - - /** - */ - void IncrementCounter() { - if (_handle == nullptr) throw std::runtime_error("ResourceHandle: Empty handle"); - ResourceHandleIncrementCounter(_handle); - } - - /** - * @return int32 - */ - int32_t GetCounter() { - if (_handle == nullptr) throw std::runtime_error("ResourceHandle: Empty handle"); - return ResourceHandleGetCounter(_handle); - } - - /** - * @param value (float) - */ - void AddData(float value) { - if (_handle == nullptr) throw std::runtime_error("ResourceHandle: Empty handle"); - ResourceHandleAddData(_handle, value); - } - - /** - * @return float[] - */ - plg::vector GetData() { - if (_handle == nullptr) throw std::runtime_error("ResourceHandle: Empty handle"); - return ResourceHandleGetData(_handle); - } - - /** - * @return int32 - */ - static int32_t GetAliveCount() { - return ResourceHandleGetAliveCount(); - } - - /** - * @return int32 - */ - static int32_t GetTotalCreated() { - return ResourceHandleGetTotalCreated(); - } - - /** - * @return int32 - */ - static int32_t GetTotalDestroyed() { - return ResourceHandleGetTotalDestroyed(); - } - - private: - void destroy() const noexcept { - if (_handle != nullptr && _ownership == Ownership::Owned) { - ResourceHandleDestroy(_handle); - } - } - - void nullify() noexcept { - _handle = nullptr; - _ownership = Ownership::Borrowed; - } - - void* _handle{nullptr}; - Ownership _ownership{Ownership::Borrowed}; - }; - - - /** - */ - class Counter final { - public: - //Counter() = default; - - /** - * @param initialValue (int64) - */ - explicit Counter(int64_t initialValue) - : Counter(CounterCreate(initialValue), Ownership::Owned) {} - - /** - */ - explicit Counter() - : Counter(CounterCreateZero(), Ownership::Owned) {} - - Counter(const Counter&) = default; - Counter& operator=(const Counter&) = default; - Counter(Counter&&) noexcept = default; - Counter& operator=(Counter&&) noexcept = default; - ~Counter() = default; - - explicit Counter(void* handle, Ownership) : _handle(handle) {} - - [[nodiscard]] auto get() const noexcept { return _handle; } - - [[nodiscard]] auto release() noexcept { - auto handle = _handle; - _handle = nullptr; - return handle; - } - - void reset() noexcept { - _handle = nullptr; - } - - void swap(Counter& other) noexcept { - using std::swap; - swap(_handle, other._handle); - } - - friend void swap(Counter& lhs, Counter& rhs) noexcept { lhs.swap(rhs); } - - explicit operator bool() const noexcept { return _handle != nullptr; } - [[nodiscard]] auto operator<=>(const Counter& other) const noexcept { return _handle <=> other._handle; } - [[nodiscard]] bool operator==(const Counter& other) const noexcept { return _handle == other._handle; } - - /** - * @return int64 - */ - int64_t GetValue() { - if (_handle == nullptr) throw std::runtime_error("Counter: Empty handle"); - return CounterGetValue(_handle); - } - - /** - * @param value (int64) - */ - void SetValue(int64_t value) { - if (_handle == nullptr) throw std::runtime_error("Counter: Empty handle"); - CounterSetValue(_handle, value); - } - - /** - */ - void Increment() { - if (_handle == nullptr) throw std::runtime_error("Counter: Empty handle"); - CounterIncrement(_handle); - } - - /** - */ - void Decrement() { - if (_handle == nullptr) throw std::runtime_error("Counter: Empty handle"); - CounterDecrement(_handle); - } - - /** - * @param amount (int64) - */ - void Add(int64_t amount) { - if (_handle == nullptr) throw std::runtime_error("Counter: Empty handle"); - CounterAdd(_handle, amount); - } - - /** - */ - void Reset() { - if (_handle == nullptr) throw std::runtime_error("Counter: Empty handle"); - CounterReset(_handle); - } - - /** - * @return bool - */ - bool IsPositive() { - if (_handle == nullptr) throw std::runtime_error("Counter: Empty handle"); - return CounterIsPositive(_handle); - } - - /** - * @param value1 (int64) - * @param value2 (int64) - * @return int32 - */ - static int32_t Compare(int64_t value1, int64_t value2) { - return CounterCompare(value1, value2); - } - - /** - * @param values (int64[]) - * @return int64 - */ - static int64_t Sum(const plg::vector& values) { - return CounterSum(values); - } - - private: - void* _handle{nullptr}; - }; - -} // namespace cross_call_master diff --git a/test/cross_call_worker/plugin.cpp b/test/cross_call_worker/plugin.cpp index 3a62714..ac06742 100644 --- a/test/cross_call_worker/plugin.cpp +++ b/test/cross_call_worker/plugin.cpp @@ -6,7 +6,7 @@ #include #include #include -#include +#include #include #include #include @@ -2038,10 +2038,10 @@ class TestClass { static plg::string OwnershipTransfer() { Log("TEST 7: Ownership Transfer (get + release)"); - Log("─────────────────────────────────────────"); + Log("_________________________________________"); int initial_alive = cross_call_master::ResourceHandle::GetAliveCount(); - int initial_created = cross_call_master::ResourceHandle::GetTotalCreated(); + [[maybe_unused]] int initial_created = cross_call_master::ResourceHandle::GetTotalCreated(); cross_call_master::ResourceHandle resource(42, "OwnershipTest"); Log(std::format("v Created ResourceHandle ID: {}", resource.GetId())); @@ -2065,7 +2065,7 @@ class TestClass { resource.GetId(); Log("x TEST 7 FAILED: ResourceHandle still accessible after release()"); return "false"; - } catch (const std::exception& e) { + } catch (const std::exception&) { Log("v ResourceHandle is invalid after release()"); } diff --git a/test/example_plugin/external/plugify/include/plg/plugin.hpp b/test/example_plugin/external/plugify/include/plg/plugin.hpp index 550b623..9308ea9 100644 --- a/test/example_plugin/external/plugify/include/plg/plugin.hpp +++ b/test/example_plugin/external/plugify/include/plg/plugin.hpp @@ -7,6 +7,7 @@ #include #include #include +#include #include #include "plg/any.hpp" @@ -14,8 +15,6 @@ #include "plg/api.hpp" namespace plg { - using GetMethodPtrFn = void* (*)(std::string_view); - using GetMethodPtr2Fn = void (*)(std::string_view, void**); using GetBaseDirFn = plg::string (*)(); using GetExtensionsDirFn = plg::string (*)(); using GetConfigsDirFn = plg::string (*)(); @@ -24,8 +23,6 @@ namespace plg { using GetCacheDirFn = plg::string (*)(); using IsExtensionLoadedFn = bool (*)(std::string_view, std::optional>); - extern GetMethodPtrFn GetMethodPtr; - extern GetMethodPtr2Fn GetMethodPtr2; extern GetBaseDirFn GetBaseDir; extern GetExtensionsDirFn GetExtensionsDir; extern GetConfigsDirFn GetConfigsDir; @@ -90,8 +87,6 @@ namespace plg { #define EXPOSE_PLUGIN(plugin_api, plugin_class, plugin_addr) \ namespace plg { \ - GetMethodPtrFn GetMethodPtr{nullptr}; \ - GetMethodPtr2Fn GetMethodPtr2{nullptr}; \ GetBaseDirFn GetBaseDir{nullptr}; \ GetExtensionsDirFn GetExtensionsDir{nullptr}; \ GetConfigsDirFn GetConfigsDir{nullptr}; \ @@ -111,13 +106,12 @@ namespace plg { GetLocationFn GetLocation{nullptr}; \ GetDependenciesFn GetDependencies{nullptr}; \ } \ - extern "C" plugin_api int Plugify_Init(void** api, int version, void* handle) { \ + extern "C" plugin_api int Plugify_Init(void** data, size_t len, int version, void* handle) { \ if (version < kApiVersion) { \ return kApiVersion; \ } \ + std::span api(data, len); \ size_t i = 0; \ - GetMethodPtr = reinterpret_cast(api[i++]); \ - GetMethodPtr2 = reinterpret_cast(api[i++]); \ GetBaseDir = reinterpret_cast(api[i++]); \ GetExtensionsDir = reinterpret_cast(api[i++]); \ GetConfigsDir = reinterpret_cast(api[i++]); \ @@ -180,16 +174,17 @@ namespace plg { namespace plg { namespace raw { + template struct vector { - uint8_t pad[sizeof(plg::vector)]{}; + alignas(plg::vector) unsigned char pad[sizeof(plg::vector)]{}; }; struct string { - uint8_t pad[sizeof(plg::string)]{}; + alignas(plg::string) unsigned char pad[sizeof(plg::string)]{}; }; struct variant { - uint8_t pad[sizeof(plg::any)]{}; + alignas(plg::any) unsigned char pad[sizeof(plg::any)]{}; }; } // namespace raw From 4fa9ff2ac29e1d276dffe800369c461bf43f358d Mon Sep 17 00:00:00 2001 From: qubka Date: Sat, 13 Dec 2025 14:07:01 +0000 Subject: [PATCH 4/6] feat: rework native system --- external/plugify | 2 +- include/plg/plugin.hpp | 19 ++++++----------- src/module.cpp | 48 ++++++++---------------------------------- src/module.hpp | 10 ++------- 4 files changed, 19 insertions(+), 60 deletions(-) diff --git a/external/plugify b/external/plugify index d55fb6b..0ff451e 160000 --- a/external/plugify +++ b/external/plugify @@ -1 +1 @@ -Subproject commit d55fb6b3b88470de1b60ca558b60c91b05e0f78c +Subproject commit 0ff451eb70564bfae7048f879042ee4b1f03ffef diff --git a/include/plg/plugin.hpp b/include/plg/plugin.hpp index 550b623..9308ea9 100644 --- a/include/plg/plugin.hpp +++ b/include/plg/plugin.hpp @@ -7,6 +7,7 @@ #include #include #include +#include #include #include "plg/any.hpp" @@ -14,8 +15,6 @@ #include "plg/api.hpp" namespace plg { - using GetMethodPtrFn = void* (*)(std::string_view); - using GetMethodPtr2Fn = void (*)(std::string_view, void**); using GetBaseDirFn = plg::string (*)(); using GetExtensionsDirFn = plg::string (*)(); using GetConfigsDirFn = plg::string (*)(); @@ -24,8 +23,6 @@ namespace plg { using GetCacheDirFn = plg::string (*)(); using IsExtensionLoadedFn = bool (*)(std::string_view, std::optional>); - extern GetMethodPtrFn GetMethodPtr; - extern GetMethodPtr2Fn GetMethodPtr2; extern GetBaseDirFn GetBaseDir; extern GetExtensionsDirFn GetExtensionsDir; extern GetConfigsDirFn GetConfigsDir; @@ -90,8 +87,6 @@ namespace plg { #define EXPOSE_PLUGIN(plugin_api, plugin_class, plugin_addr) \ namespace plg { \ - GetMethodPtrFn GetMethodPtr{nullptr}; \ - GetMethodPtr2Fn GetMethodPtr2{nullptr}; \ GetBaseDirFn GetBaseDir{nullptr}; \ GetExtensionsDirFn GetExtensionsDir{nullptr}; \ GetConfigsDirFn GetConfigsDir{nullptr}; \ @@ -111,13 +106,12 @@ namespace plg { GetLocationFn GetLocation{nullptr}; \ GetDependenciesFn GetDependencies{nullptr}; \ } \ - extern "C" plugin_api int Plugify_Init(void** api, int version, void* handle) { \ + extern "C" plugin_api int Plugify_Init(void** data, size_t len, int version, void* handle) { \ if (version < kApiVersion) { \ return kApiVersion; \ } \ + std::span api(data, len); \ size_t i = 0; \ - GetMethodPtr = reinterpret_cast(api[i++]); \ - GetMethodPtr2 = reinterpret_cast(api[i++]); \ GetBaseDir = reinterpret_cast(api[i++]); \ GetExtensionsDir = reinterpret_cast(api[i++]); \ GetConfigsDir = reinterpret_cast(api[i++]); \ @@ -180,16 +174,17 @@ namespace plg { namespace plg { namespace raw { + template struct vector { - uint8_t pad[sizeof(plg::vector)]{}; + alignas(plg::vector) unsigned char pad[sizeof(plg::vector)]{}; }; struct string { - uint8_t pad[sizeof(plg::string)]{}; + alignas(plg::string) unsigned char pad[sizeof(plg::string)]{}; }; struct variant { - uint8_t pad[sizeof(plg::any)]{}; + alignas(plg::any) unsigned char pad[sizeof(plg::any)]{}; }; } // namespace raw diff --git a/src/module.cpp b/src/module.cpp index 2a33b23..8c258c7 100644 --- a/src/module.cpp +++ b/src/module.cpp @@ -20,11 +20,6 @@ Result CppLanguageModule::Initialize(const Provider& provider, [[maybe } void CppLanguageModule::Shutdown() { - for (MemAddr* addr : _addresses) { - *addr = nullptr; - } - _nativesMap.clear(); - _addresses.clear(); _assemblies.clear(); _provider.reset(); } @@ -38,10 +33,13 @@ bool CppLanguageModule::IsDebugBuild() { } void CppLanguageModule::OnMethodExport(const Extension& plugin) { - const auto& methods = plugin.GetMethodsData(); - _nativesMap.reserve(_nativesMap.size() + methods.size()); - for (const auto& [method, addr] : methods) { - _nativesMap.try_emplace(std::format("{}.{}", plugin.GetName(), method.GetName()), addr); + for (const auto& [method, addr] : plugin.GetMethodsData()) { + auto variableName = std::format("__{}_{}", plugin.GetName(), method.GetName()); + for (const auto& assembly : _assemblies) { + if (auto function = assembly->assembly->GetSymbol(variableName)) { + *function->RCast() = addr; + } + } } } @@ -110,7 +108,7 @@ Result CppLanguageModule::OnPluginLoad(const Extension& plugin) { return MakeError("Invalid methods:\n{}", plg::join(errors, "\n")); } - const int requiredVersion = initFunc(_pluginApi.data(), plg::kApiVersion, static_cast(&plugin)); + const int requiredVersion = initFunc(_pluginApi.data(), _pluginApi.size(), plg::kApiVersion, static_cast(&plugin)); if (requiredVersion != 0) { return MakeError("Not supported plugin api {}, max supported {}", requiredVersion, plg::kApiVersion); } @@ -142,36 +140,10 @@ void CppLanguageModule::OnPluginEnd(const Extension& plugin) { plugin.GetUserData().RCast()->endFunc(); } -// Plugin API methods -MemAddr CppLanguageModule::GetNativeMethod(std::string_view methodName) const { - if (const auto it = _nativesMap.find(methodName); it != _nativesMap.end()) { - return std::get(*it); - } - _provider->Log(std::format(LOG_PREFIX "GetNativeMethod failed to find {}", methodName), Severity::Fatal); - return nullptr; -} - -void CppLanguageModule::GetNativeMethod(std::string_view methodName, MemAddr* addressDest) { - if (const auto it = _nativesMap.find(methodName); it != _nativesMap.end()) { - *addressDest = std::get(*it); - _addresses.emplace_back(addressDest); - return; - } - _provider->Log(std::format(LOG_PREFIX "GetNativeMethod failed to find: '{}'", methodName), Severity::Fatal); -} - namespace cpplm { CppLanguageModule g_cpplm; } -void* GetMethodPtr(std::string_view name) { - return g_cpplm.GetNativeMethod(name); -} - -void GetMethodPtr2(std::string_view name, MemAddr* dest) { - g_cpplm.GetNativeMethod(name, dest); -} - plg::string GetBaseDir() { return plg::as_string(g_cpplm.GetProvider()->GetBaseDir()); } @@ -252,9 +224,7 @@ std::vector GetPluginDependencies(const Extension& plugin) { return deps; } -std::array CppLanguageModule::_pluginApi = { - reinterpret_cast(&::GetMethodPtr), - reinterpret_cast(&::GetMethodPtr2), +std::array CppLanguageModule::_pluginApi = { reinterpret_cast(&::GetBaseDir), reinterpret_cast(&::GetExtensionsDir), reinterpret_cast(&::GetConfigsDir), diff --git a/src/module.hpp b/src/module.hpp index 25d1668..6a2da4c 100644 --- a/src/module.hpp +++ b/src/module.hpp @@ -15,7 +15,7 @@ using namespace plugify; namespace cpplm { - using InitFunc = int (*)(void**, int, const void*); + using InitFunc = int (*)(void**, size_t, int, const void*); using StartFunc = void (*)(); using UpdateFunc = void (*)(std::chrono::milliseconds); using EndFunc = void (*)(); @@ -45,18 +45,12 @@ namespace cpplm { bool IsDebugBuild() override; const std::unique_ptr& GetProvider() const { return _provider; } - MemAddr GetNativeMethod(std::string_view methodName) const; - void GetNativeMethod(std::string_view methodName, MemAddr* addressDest); private: std::unique_ptr _provider; - std::vector> _assemblies; - std::unordered_map> _nativesMap; - - std::vector _addresses; - static std::array _pluginApi; + static std::array _pluginApi; }; extern CppLanguageModule g_cpplm; From ddb771255bb06c3b85b2325c238a1b8374dad33f Mon Sep 17 00:00:00 2001 From: qubka Date: Sat, 13 Dec 2025 14:46:05 +0000 Subject: [PATCH 5/6] fix: update plugify --- include/plg/allocator.hpp | 40 ++- include/plg/enum.hpp | 17 +- include/plg/hash.hpp | 18 +- include/plg/hybrid_vector.hpp | 335 ++++++++++++++++++ include/plg/inplace_vector.hpp | 20 +- include/plg/string.hpp | 30 +- include/plg/vector.hpp | 78 ++++ .../plugify/include/plg/allocator.hpp | 40 ++- .../external/plugify/include/plg/enum.hpp | 17 +- .../external/plugify/include/plg/hash.hpp | 18 +- .../plugify/include/plg/hybrid_vector.hpp | 335 ++++++++++++++++++ .../plugify/include/plg/inplace_vector.hpp | 20 +- .../external/plugify/include/plg/string.hpp | 20 +- .../external/plugify/include/plg/vector.hpp | 78 ++++ .../plugify/include/plg/allocator.hpp | 40 ++- .../external/plugify/include/plg/enum.hpp | 17 +- .../external/plugify/include/plg/hash.hpp | 18 +- .../plugify/include/plg/hybrid_vector.hpp | 335 ++++++++++++++++++ .../plugify/include/plg/inplace_vector.hpp | 20 +- .../external/plugify/include/plg/string.hpp | 20 +- .../external/plugify/include/plg/vector.hpp | 78 ++++ .../plugify/include/plg/allocator.hpp | 40 ++- .../external/plugify/include/plg/enum.hpp | 17 +- .../external/plugify/include/plg/hash.hpp | 18 +- .../plugify/include/plg/hybrid_vector.hpp | 335 ++++++++++++++++++ .../plugify/include/plg/inplace_vector.hpp | 20 +- .../external/plugify/include/plg/string.hpp | 20 +- .../external/plugify/include/plg/vector.hpp | 78 ++++ 28 files changed, 1997 insertions(+), 125 deletions(-) create mode 100644 include/plg/hybrid_vector.hpp create mode 100644 test/cross_call_master/external/plugify/include/plg/hybrid_vector.hpp create mode 100644 test/cross_call_worker/external/plugify/include/plg/hybrid_vector.hpp create mode 100644 test/example_plugin/external/plugify/include/plg/hybrid_vector.hpp diff --git a/include/plg/allocator.hpp b/include/plg/allocator.hpp index 3bb603d..8cbcbf7 100644 --- a/include/plg/allocator.hpp +++ b/include/plg/allocator.hpp @@ -47,7 +47,11 @@ namespace plg { size_type size = n * sizeof(T); if (std::is_constant_evaluated()) { - return static_cast(::operator new(size)); + if constexpr (alignof(T) > alignof(std::max_align_t)) { + return static_cast(::operator new(size, std::align_val_t{alignof(T)})); + } else { + return static_cast(::operator new(size)); + } } else { return malloc_allocate(size); } @@ -55,9 +59,13 @@ namespace plg { constexpr void deallocate(T* p, [[maybe_unused]] size_type n) { if (std::is_constant_evaluated()) { - ::operator delete(p); + if constexpr (alignof(T) > alignof(std::max_align_t)) { + ::operator delete(p, std::align_val_t{alignof(T)}); + } else { + ::operator delete(p); + } } else { - std::free(p); + malloc_deallocate(p); } } @@ -65,8 +73,7 @@ namespace plg { static T* malloc_allocate(size_type size) { T* ret; if constexpr (alignof(T) > alignof(std::max_align_t)) { - size_type aligned_size = (size + (alignof(T) - 1)) & ~(alignof(T) - 1); - ret = static_cast(aligned_allocate(alignof(T), aligned_size)); + ret = static_cast(aligned_allocate(size)); } else { ret = static_cast(std::malloc(size)); } @@ -76,6 +83,14 @@ namespace plg { return ret; } + static void malloc_deallocate(T* ptr) { + if constexpr (alignof(T) > alignof(std::max_align_t)) { + aligned_deallocate(ptr); + } else { + std::free(ptr); + } + } + [[noreturn]] static void throw_bad_array_new_length() { PLUGIFY_THROW("bad array new length", std::bad_array_new_length); } @@ -84,11 +99,20 @@ namespace plg { PLUGIFY_THROW("bad allocation", std::bad_alloc); } - static void* aligned_allocate(size_type alignment, size_type size) { + static void* aligned_allocate(size_type size) { +#if PLUGIFY_PLATFORM_WINDOWS + return _aligned_malloc(size, alignof(T)); +#else + size_type aligned_size = (size + (alignof(T) - 1)) & ~(alignof(T) - 1); + return std::aligned_alloc(alignof(T), aligned_size); +#endif // PLUGIFY_PLATFORM_WINDOWS + } + + static void aligned_deallocate(void* ptr) { #if PLUGIFY_PLATFORM_WINDOWS - return _aligned_malloc(size, alignment); + _aligned_free(ptr); #else - return std::aligned_alloc(alignment, size); + std::free(ptr); #endif // PLUGIFY_PLATFORM_WINDOWS } }; diff --git a/include/plg/enum.hpp b/include/plg/enum.hpp index 0692a31..1e159d0 100644 --- a/include/plg/enum.hpp +++ b/include/plg/enum.hpp @@ -28,17 +28,16 @@ namespace plg { std::array content_{}; }; - constexpr auto is_pretty(char ch) noexcept { - return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'); - } - constexpr auto pretty_name(std::string_view sv) noexcept { - for (std::size_t n = sv.size() - 1; n > 0; --n) { - if (!is_pretty(sv[n])) { - sv.remove_prefix(n + 1); - break; - } + // Find last non-pretty character from the end + auto pos = sv.find_last_not_of( + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_" + ); + + if (pos != std::string_view::npos) { + sv.remove_prefix(pos + 1); } + return sv; } diff --git a/include/plg/hash.hpp b/include/plg/hash.hpp index 982f796..6a20926 100644 --- a/include/plg/hash.hpp +++ b/include/plg/hash.hpp @@ -73,6 +73,19 @@ namespace plg { struct case_insensitive_equal { using is_transparent = void; // Enables heterogeneous lookup + template + bool operator()(const T1& lhs, const T2& rhs) const noexcept { + return lhs.size() == rhs.size() && + std::equal(lhs.begin(), lhs.end(), rhs.begin(), + [](const auto& ac, const auto& bc) { + return std::tolower(ac) == std::tolower(bc); + }); + } + }; + + struct case_insensitive_compare { + using is_transparent = void; // Enables heterogeneous lookup + template bool operator()(const T1& lhs, const T2& rhs) const noexcept { return std::lexicographical_compare( @@ -85,8 +98,7 @@ namespace plg { } }; - inline void hash_combine(size_t&) { - } + inline void hash_combine(std::size_t&) {} template inline void hash_combine(std::size_t& seed, const T& v) { @@ -103,7 +115,7 @@ namespace plg { template struct pair_hash { - size_t operator()(const std::pair& p) const { + std::size_t operator()(const std::pair& p) const { return hash_combine_all(p.first, p.second); } }; diff --git a/include/plg/hybrid_vector.hpp b/include/plg/hybrid_vector.hpp new file mode 100644 index 0000000..9fe60f0 --- /dev/null +++ b/include/plg/hybrid_vector.hpp @@ -0,0 +1,335 @@ +#pragma once + +#include "plg/vector.hpp" +#include "plg/inplace_vector.hpp" +#include "plg/variant.hpp" + +namespace plg { + // hybrid container that uses std::inplace_vector for stack storage up to N elements, then switches to std::vector for larger sizes. + template requires (N > 0) + class hybrid_vector { + private: + variant, vector> storage_; + + // Check if currently using stack storage + [[nodiscard]] constexpr bool is_small() const noexcept { + return storage_.index() == 0; + } + + // Promote from stack to heap storage + constexpr void promote_to_heap() { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + vector heap_vec( + std::make_move_iterator(small_vec.begin()), + std::make_move_iterator(small_vec.end()) + ); + storage_.template emplace<1>(std::move(heap_vec)); + } + } + + public: + using value_type = T; + using size_type = std::size_t; + using reference = T&; + using const_reference = const T&; + + // Constructors + constexpr hybrid_vector() noexcept + : storage_(in_place_index<0>) {} + + constexpr explicit hybrid_vector(size_type count) + : storage_(count <= N ? + variant, vector>( + in_place_index<0>, count) : + variant, vector>( + in_place_index<1>, count)) {} + + constexpr hybrid_vector(size_type count, const T& value) + : storage_(count <= N ? + variant, vector>( + in_place_index<0>, count, value) : + variant, vector>( + in_place_index<1>, count, value)) {} + + template + constexpr hybrid_vector(It first, It last) { + if constexpr (std::random_access_iterator) { + auto count = std::distance(first, last); + if (count <= static_cast(N)) { + storage_.template emplace<0>(first, last); + } else { + storage_.template emplace<1>(first, last); + } + } else { + storage_.template emplace<0>(); + for (; first != last; ++first) { + push_back(*first); + } + } + } + + constexpr hybrid_vector(std::initializer_list init) + : hybrid_vector(init.begin(), init.end()) {} + + // Size operations using C++23 explicit object parameter (deducing this) + [[nodiscard]] constexpr size_type size(this auto&& self) noexcept { + return plg::visit([](auto&& vec) { return vec.size(); }, self.storage_); + } + + [[nodiscard]] constexpr size_type capacity(this auto&& self) noexcept { + return plg::visit([](auto&& vec) { return vec.capacity(); }, self.storage_); + } + + [[nodiscard]] constexpr bool empty(this auto&& self) noexcept { + return self.size() == 0; + } + + [[nodiscard]] static constexpr size_type max_stack_size() noexcept { + return N; + } + + // Element access using C++23 explicit object parameter + [[nodiscard]] constexpr reference operator[](this auto&& self, size_type pos) { + return plg::visit([pos](auto&& vec) -> reference { + return vec[pos]; + }, self.storage_); + } + + [[nodiscard]] constexpr reference at(this auto&& self, size_type pos) { + return plg::visit([pos](auto&& vec) -> reference { + return vec.at(pos); + }, self.storage_); + } + + [[nodiscard]] constexpr reference front(this auto&& self) { + return plg::visit([](auto&& vec) -> reference { + return vec.front(); + }, self.storage_); + } + + [[nodiscard]] constexpr reference back(this auto&& self) { + return plg::visit([](auto&& vec) -> reference { + return vec.back(); + }, self.storage_); + } + + // Modifiers + constexpr void push_back(const T& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + small_vec.push_back(value); + } else { + promote_to_heap(); + plg::get<1>(storage_).push_back(value); + } + } else { + plg::get<1>(storage_).push_back(value); + } + } + + constexpr void push_back(T&& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + small_vec.push_back(std::move(value)); + } else { + promote_to_heap(); + plg::get<1>(storage_).push_back(std::move(value)); + } + } else { + plg::get<1>(storage_).push_back(std::move(value)); + } + } + + template + constexpr reference emplace_back(Args&&... args) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + return small_vec.emplace_back(std::forward(args)...); + } else { + promote_to_heap(); + return plg::get<1>(storage_).emplace_back(std::forward(args)...); + } + } else { + return plg::get<1>(storage_).emplace_back(std::forward(args)...); + } + } + + constexpr void pop_back() { + plg::visit([](auto&& vec) { vec.pop_back(); }, storage_); + } + + constexpr void clear() noexcept { + plg::visit([](auto&& vec) { vec.clear(); }, storage_); + } + + // Insert single element (copy) + constexpr auto insert(auto pos, const T& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + return small_vec.insert(pos, value); + } else { + promote_to_heap(); + return plg::get<1>(storage_).insert(pos, value); + } + } else { + return plg::get<1>(storage_).insert(pos, value); + } + } + + // Insert single element (move) + constexpr auto insert(auto pos, T&& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + return small_vec.insert(pos, std::move(value)); + } else { + promote_to_heap(); + return plg::get<1>(storage_).insert(pos, std::move(value)); + } + } else { + return plg::get<1>(storage_).insert(pos, std::move(value)); + } + } + + // Insert count copies + constexpr auto insert(auto pos, size_type count, const T& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() + count <= N) { + return small_vec.insert(pos, count, value); + } else { + promote_to_heap(); + return plg::get<1>(storage_).insert(pos, count, value); + } + } else { + return plg::get<1>(storage_).insert(pos, count, value); + } + } + + // Insert range + template + constexpr auto insert(auto pos, It first, It last) { + if constexpr (std::random_access_iterator) { + auto count = std::distance(first, last); + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() + count <= N) { + return small_vec.insert(pos, first, last); + } else { + promote_to_heap(); + return plg::get<1>(storage_).insert(pos, first, last); + } + } else { + return plg::get<1>(storage_).insert(pos, first, last); + } + } else { + // For non-random-access iterators, insert one by one + auto result = pos; + for (; first != last; ++first) { + result = insert(result, *first); + ++result; + } + return result; + } + } + + // Insert initializer list + constexpr auto insert(auto pos, std::initializer_list ilist) { + return insert(pos, ilist.begin(), ilist.end()); + } + + template + constexpr void append_range(R&& range) { + for (auto&& elem : range) { + push_back(std::forward(elem)); + } + } + + // Append from iterator range + template + constexpr void append(It first, It last) { + for (; first != last; ++first) { + push_back(*first); + } + } + + // Append from initializer list + constexpr void append(std::initializer_list ilist) { + append(ilist.begin(), ilist.end()); + } + + // Erase single element + constexpr auto erase(auto pos) { + return plg::visit([pos](auto&& vec) { return vec.erase(pos); }, storage_); + } + + // Swap contents with another hybrid_vector + constexpr void swap(hybrid_vector& other) noexcept { + storage_.swap(other.storage_); + } + + // Non-member swap for ADL + friend constexpr void swap(hybrid_vector& lhs, hybrid_vector& rhs) noexcept { + lhs.swap(rhs); + } + + // Reserve capacity + constexpr void reserve(size_type new_cap) { + if (new_cap <= N) { + // Stack storage already has capacity N, nothing to do + return; + } + + // Need heap storage for capacity > N + if (is_small()) { + promote_to_heap(); + } + + plg::get<1>(storage_).reserve(new_cap); + } + + // Erase range + constexpr auto erase(auto first, auto last) { + return plg::visit([first, last](auto&& vec) { return vec.erase(first, last); }, storage_); + } + + // Iterators + [[nodiscard]] constexpr auto begin(this auto&& self) { + return plg::visit([](auto&& vec) { return vec.begin(); }, self.storage_); + } + + [[nodiscard]] constexpr auto end(this auto&& self) { + return plg::visit([](auto&& vec) { return vec.end(); }, self.storage_); + } + + [[nodiscard]] constexpr auto cbegin(this auto&& self) { + return plg::visit([](auto&& vec) { return vec.cbegin(); }, self.storage_); + } + + [[nodiscard]] constexpr auto cend(this auto&& self) { + return plg::visit([](auto&& vec) { return vec.cend(); }, self.storage_); + } + + // Range support (C++23) + [[nodiscard]] friend constexpr auto begin(hybrid_vector& v) { + return v.begin(); + } + + [[nodiscard]] friend constexpr auto end(hybrid_vector& v) { + return v.end(); + } + + [[nodiscard]] friend constexpr auto cbegin(hybrid_vector& v) { + return v.cbegin(); + } + + [[nodiscard]] friend constexpr auto cend(hybrid_vector& v) { + return v.cend(); + } + }; +} \ No newline at end of file diff --git a/include/plg/inplace_vector.hpp b/include/plg/inplace_vector.hpp index db59904..5a6d279 100644 --- a/include/plg/inplace_vector.hpp +++ b/include/plg/inplace_vector.hpp @@ -83,7 +83,8 @@ namespace plg { noexcept(std::is_nothrow_copy_constructible_v) { if constexpr (std::is_trivially_copy_constructible_v) { - std::memmove((void*)this, (const void*)std::addressof(rhs), sizeof(ipvbase)); + std::memcpy(data_, rhs.data_, rhs.size_ * sizeof(T)); + size_ = rhs.size_; } else { std::uninitialized_copy_n(rhs.data_, rhs.size_, data_); size_ = rhs.size_; @@ -97,7 +98,8 @@ namespace plg { ) { if constexpr (std::is_trivially_move_constructible_v) { - std::memmove((void*)this, (const void*)std::addressof(rhs), sizeof(ipvbase)); + std::memcpy(data_, rhs.data_, rhs.size_ * sizeof(T)); + size_ = rhs.size_; #if defined(__cpp_lib_trivially_relocatable) } else if constexpr (std::is_trivially_relocatable_v) { std::uninitialized_relocate_n(rhs.data_, rhs.size_, data_); @@ -112,10 +114,11 @@ namespace plg { void operator=(const ipvbase& rhs) noexcept(std::is_nothrow_copy_constructible_v && std::is_nothrow_copy_assignable_v) { + if (this == std::addressof(rhs)) return; + if constexpr (std::is_trivially_copy_constructible_v && std::is_trivially_copy_assignable_v && std::is_trivially_destructible_v) { - std::memmove((void*)this, (const void*)std::addressof(rhs), sizeof(ipvbase)); - } else if (this == std::addressof(rhs)) { - // do nothing + std::memcpy(data_, rhs.data_, rhs.size_ * sizeof(T)); + size_ = rhs.size_; } else if (rhs.size_ <= size_) { std::copy(rhs.data_, rhs.data_ + rhs.size_, data_); std::destroy(data_ + rhs.size_, data_ + size_); @@ -129,10 +132,11 @@ namespace plg { void operator=(ipvbase&& rhs) noexcept(std::is_nothrow_move_constructible_v && std::is_nothrow_move_assignable_v) { + if (this == std::addressof(rhs)) return; + if constexpr (std::is_trivially_move_constructible_v && std::is_trivially_move_assignable_v && std::is_trivially_destructible_v) { - std::memmove((void*)this, (const void*)std::addressof(rhs), sizeof(ipvbase)); - } else if (this == std::addressof(rhs)) { - // do nothing + std::memcpy(data_, rhs.data_, rhs.size_ * sizeof(T)); + size_ = rhs.size_; } else if (rhs.size_ <= size_) { std::move(rhs.data_, rhs.data_ + rhs.size_, data_); std::destroy(data_ + rhs.size_, data_ + size_); diff --git a/include/plg/string.hpp b/include/plg/string.hpp index e6c08e8..fb63392 100644 --- a/include/plg/string.hpp +++ b/include/plg/string.hpp @@ -1890,7 +1890,7 @@ namespace plg { // starts_with constexpr bool starts_with(self_view sv) const noexcept { - return self_view(typename self_view::assume_valid(), data(), size()).starts_with(sv); + return self_view(data(), size()).starts_with(sv); } constexpr bool starts_with(value_type c) const noexcept { @@ -1904,7 +1904,7 @@ namespace plg { // ends_with constexpr bool ends_with(self_view sv) const noexcept { - return self_view(typename self_view::assume_valid(), data(), size()).ends_with(sv); + return self_view(data(), size()).ends_with(sv); } constexpr bool ends_with(value_type c) const noexcept { @@ -1918,15 +1918,15 @@ namespace plg { // contains constexpr bool contains(self_view sv) const noexcept { - return self_view(typename self_view::assume_valid(), data(), size()).contains(sv); + return self_view(data(), size()).contains(sv); } constexpr bool contains(value_type c) const noexcept { - return self_view(typename self_view::assume_valid(), data(), size()).contains(c); + return self_view(data(), size()).contains(c); } constexpr bool contains(const value_type* PLUGIFY_NO_NULL s) const { - return self_view(typename self_view::assume_valid(), data(), size()).contains(s); + return self_view(data(), size()).contains(s); } [[nodiscard]] constexpr bool invariants() const; @@ -2148,18 +2148,34 @@ namespace plg { } constexpr void annotate_new(size_type current_size) const noexcept { + if (!is_long()) { + return; + } + annotate_contiguous_container(data() + capacity() + 1, data() + current_size + 1); } constexpr void annotate_delete() const noexcept { + if (!is_long()) { + return; + } + annotate_contiguous_container(data() + size() + 1, data() + capacity() + 1); } constexpr void annotate_increase(size_type n) const noexcept { + if (!is_long()) { + return; + } + annotate_contiguous_container(data() + size() + 1, data() + size() + 1 + n); } constexpr void annotate_shrink(size_type old_size) const noexcept { + if (!is_long()) { + return; + } + annotate_contiguous_container(data() + old_size + 1, data() + size() + 1); } @@ -3935,7 +3951,7 @@ std::ostream& operator<<(std::ostream& os, const plg::basic_string namespace plg { @@ -4024,4 +4040,4 @@ namespace plg { return result; } } // namespace plugify -#endif // PLUGIFY_STRING_NO_STD_FORMAT \ No newline at end of file +#endif // PLUGIFY_STRING_NO_STD_UTIL diff --git a/include/plg/vector.hpp b/include/plg/vector.hpp index 56884fc..bf562c3 100644 --- a/include/plg/vector.hpp +++ b/include/plg/vector.hpp @@ -1572,3 +1572,81 @@ namespace plg { using vector = ::plg::vector>; } // namespace pmr } // namespace plg + +#ifndef PLUGIFY_VECTOR_NO_STD_UTIL +#include +#include +#include + +namespace plg { + constexpr vector split(std::string_view str, std::string_view delims = " ") { + vector output; + size_t first = 0; + + while (first < str.size()) { + const size_t second = str.find_first_of(delims, first); + + if (first != second) + output.emplace_back(str.substr(first, second - first)); + + if (second == std::string_view::npos) + break; + + first = second + 1; + } + + return output; + } + + template + constexpr std::optional cast_to(std::string_view str) { + T value; + auto [ptr, ec] = std::from_chars(str.data(), str.data() + str.size(), value); + if (ec == std::errc()) { + return value; + } + return std::nullopt; + } + +#if PLUGIFY_PLATFORM_APPLE + template<> + inline std::optional cast_to(std::string_view str) { + std::string p(str); + size_t pos = 0; + try { + double v = std::stod(p, &pos); + if (pos != p.size()) return std::nullopt; + return v; + } catch (...) { + return std::nullopt; + } + } + + template<> + inline std::optional cast_to(std::string_view str) { + std::string p(str); + size_t pos = 0; + try { + float v = std::stof(p, &pos); + if (pos != p.size()) return std::nullopt; + return v; + } catch (...) { + return std::nullopt; + } + } +#endif + + template + constexpr vector parse(std::string_view str, std::string_view delims = " ") { + vector vec; + auto items = split(str, delims); + vec.reserve(items.size()); + for (const auto& item : items) { + if (auto value = cast_to(item)) { + vec.emplace_back(*value); + } + } + return vec; + } +} // namespace plugify +#endif // PLUGIFY_VECTOR_NO_STD_UTIL diff --git a/test/cross_call_master/external/plugify/include/plg/allocator.hpp b/test/cross_call_master/external/plugify/include/plg/allocator.hpp index 3bb603d..8cbcbf7 100644 --- a/test/cross_call_master/external/plugify/include/plg/allocator.hpp +++ b/test/cross_call_master/external/plugify/include/plg/allocator.hpp @@ -47,7 +47,11 @@ namespace plg { size_type size = n * sizeof(T); if (std::is_constant_evaluated()) { - return static_cast(::operator new(size)); + if constexpr (alignof(T) > alignof(std::max_align_t)) { + return static_cast(::operator new(size, std::align_val_t{alignof(T)})); + } else { + return static_cast(::operator new(size)); + } } else { return malloc_allocate(size); } @@ -55,9 +59,13 @@ namespace plg { constexpr void deallocate(T* p, [[maybe_unused]] size_type n) { if (std::is_constant_evaluated()) { - ::operator delete(p); + if constexpr (alignof(T) > alignof(std::max_align_t)) { + ::operator delete(p, std::align_val_t{alignof(T)}); + } else { + ::operator delete(p); + } } else { - std::free(p); + malloc_deallocate(p); } } @@ -65,8 +73,7 @@ namespace plg { static T* malloc_allocate(size_type size) { T* ret; if constexpr (alignof(T) > alignof(std::max_align_t)) { - size_type aligned_size = (size + (alignof(T) - 1)) & ~(alignof(T) - 1); - ret = static_cast(aligned_allocate(alignof(T), aligned_size)); + ret = static_cast(aligned_allocate(size)); } else { ret = static_cast(std::malloc(size)); } @@ -76,6 +83,14 @@ namespace plg { return ret; } + static void malloc_deallocate(T* ptr) { + if constexpr (alignof(T) > alignof(std::max_align_t)) { + aligned_deallocate(ptr); + } else { + std::free(ptr); + } + } + [[noreturn]] static void throw_bad_array_new_length() { PLUGIFY_THROW("bad array new length", std::bad_array_new_length); } @@ -84,11 +99,20 @@ namespace plg { PLUGIFY_THROW("bad allocation", std::bad_alloc); } - static void* aligned_allocate(size_type alignment, size_type size) { + static void* aligned_allocate(size_type size) { +#if PLUGIFY_PLATFORM_WINDOWS + return _aligned_malloc(size, alignof(T)); +#else + size_type aligned_size = (size + (alignof(T) - 1)) & ~(alignof(T) - 1); + return std::aligned_alloc(alignof(T), aligned_size); +#endif // PLUGIFY_PLATFORM_WINDOWS + } + + static void aligned_deallocate(void* ptr) { #if PLUGIFY_PLATFORM_WINDOWS - return _aligned_malloc(size, alignment); + _aligned_free(ptr); #else - return std::aligned_alloc(alignment, size); + std::free(ptr); #endif // PLUGIFY_PLATFORM_WINDOWS } }; diff --git a/test/cross_call_master/external/plugify/include/plg/enum.hpp b/test/cross_call_master/external/plugify/include/plg/enum.hpp index 0692a31..1e159d0 100644 --- a/test/cross_call_master/external/plugify/include/plg/enum.hpp +++ b/test/cross_call_master/external/plugify/include/plg/enum.hpp @@ -28,17 +28,16 @@ namespace plg { std::array content_{}; }; - constexpr auto is_pretty(char ch) noexcept { - return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'); - } - constexpr auto pretty_name(std::string_view sv) noexcept { - for (std::size_t n = sv.size() - 1; n > 0; --n) { - if (!is_pretty(sv[n])) { - sv.remove_prefix(n + 1); - break; - } + // Find last non-pretty character from the end + auto pos = sv.find_last_not_of( + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_" + ); + + if (pos != std::string_view::npos) { + sv.remove_prefix(pos + 1); } + return sv; } diff --git a/test/cross_call_master/external/plugify/include/plg/hash.hpp b/test/cross_call_master/external/plugify/include/plg/hash.hpp index 982f796..6a20926 100644 --- a/test/cross_call_master/external/plugify/include/plg/hash.hpp +++ b/test/cross_call_master/external/plugify/include/plg/hash.hpp @@ -73,6 +73,19 @@ namespace plg { struct case_insensitive_equal { using is_transparent = void; // Enables heterogeneous lookup + template + bool operator()(const T1& lhs, const T2& rhs) const noexcept { + return lhs.size() == rhs.size() && + std::equal(lhs.begin(), lhs.end(), rhs.begin(), + [](const auto& ac, const auto& bc) { + return std::tolower(ac) == std::tolower(bc); + }); + } + }; + + struct case_insensitive_compare { + using is_transparent = void; // Enables heterogeneous lookup + template bool operator()(const T1& lhs, const T2& rhs) const noexcept { return std::lexicographical_compare( @@ -85,8 +98,7 @@ namespace plg { } }; - inline void hash_combine(size_t&) { - } + inline void hash_combine(std::size_t&) {} template inline void hash_combine(std::size_t& seed, const T& v) { @@ -103,7 +115,7 @@ namespace plg { template struct pair_hash { - size_t operator()(const std::pair& p) const { + std::size_t operator()(const std::pair& p) const { return hash_combine_all(p.first, p.second); } }; diff --git a/test/cross_call_master/external/plugify/include/plg/hybrid_vector.hpp b/test/cross_call_master/external/plugify/include/plg/hybrid_vector.hpp new file mode 100644 index 0000000..9fe60f0 --- /dev/null +++ b/test/cross_call_master/external/plugify/include/plg/hybrid_vector.hpp @@ -0,0 +1,335 @@ +#pragma once + +#include "plg/vector.hpp" +#include "plg/inplace_vector.hpp" +#include "plg/variant.hpp" + +namespace plg { + // hybrid container that uses std::inplace_vector for stack storage up to N elements, then switches to std::vector for larger sizes. + template requires (N > 0) + class hybrid_vector { + private: + variant, vector> storage_; + + // Check if currently using stack storage + [[nodiscard]] constexpr bool is_small() const noexcept { + return storage_.index() == 0; + } + + // Promote from stack to heap storage + constexpr void promote_to_heap() { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + vector heap_vec( + std::make_move_iterator(small_vec.begin()), + std::make_move_iterator(small_vec.end()) + ); + storage_.template emplace<1>(std::move(heap_vec)); + } + } + + public: + using value_type = T; + using size_type = std::size_t; + using reference = T&; + using const_reference = const T&; + + // Constructors + constexpr hybrid_vector() noexcept + : storage_(in_place_index<0>) {} + + constexpr explicit hybrid_vector(size_type count) + : storage_(count <= N ? + variant, vector>( + in_place_index<0>, count) : + variant, vector>( + in_place_index<1>, count)) {} + + constexpr hybrid_vector(size_type count, const T& value) + : storage_(count <= N ? + variant, vector>( + in_place_index<0>, count, value) : + variant, vector>( + in_place_index<1>, count, value)) {} + + template + constexpr hybrid_vector(It first, It last) { + if constexpr (std::random_access_iterator) { + auto count = std::distance(first, last); + if (count <= static_cast(N)) { + storage_.template emplace<0>(first, last); + } else { + storage_.template emplace<1>(first, last); + } + } else { + storage_.template emplace<0>(); + for (; first != last; ++first) { + push_back(*first); + } + } + } + + constexpr hybrid_vector(std::initializer_list init) + : hybrid_vector(init.begin(), init.end()) {} + + // Size operations using C++23 explicit object parameter (deducing this) + [[nodiscard]] constexpr size_type size(this auto&& self) noexcept { + return plg::visit([](auto&& vec) { return vec.size(); }, self.storage_); + } + + [[nodiscard]] constexpr size_type capacity(this auto&& self) noexcept { + return plg::visit([](auto&& vec) { return vec.capacity(); }, self.storage_); + } + + [[nodiscard]] constexpr bool empty(this auto&& self) noexcept { + return self.size() == 0; + } + + [[nodiscard]] static constexpr size_type max_stack_size() noexcept { + return N; + } + + // Element access using C++23 explicit object parameter + [[nodiscard]] constexpr reference operator[](this auto&& self, size_type pos) { + return plg::visit([pos](auto&& vec) -> reference { + return vec[pos]; + }, self.storage_); + } + + [[nodiscard]] constexpr reference at(this auto&& self, size_type pos) { + return plg::visit([pos](auto&& vec) -> reference { + return vec.at(pos); + }, self.storage_); + } + + [[nodiscard]] constexpr reference front(this auto&& self) { + return plg::visit([](auto&& vec) -> reference { + return vec.front(); + }, self.storage_); + } + + [[nodiscard]] constexpr reference back(this auto&& self) { + return plg::visit([](auto&& vec) -> reference { + return vec.back(); + }, self.storage_); + } + + // Modifiers + constexpr void push_back(const T& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + small_vec.push_back(value); + } else { + promote_to_heap(); + plg::get<1>(storage_).push_back(value); + } + } else { + plg::get<1>(storage_).push_back(value); + } + } + + constexpr void push_back(T&& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + small_vec.push_back(std::move(value)); + } else { + promote_to_heap(); + plg::get<1>(storage_).push_back(std::move(value)); + } + } else { + plg::get<1>(storage_).push_back(std::move(value)); + } + } + + template + constexpr reference emplace_back(Args&&... args) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + return small_vec.emplace_back(std::forward(args)...); + } else { + promote_to_heap(); + return plg::get<1>(storage_).emplace_back(std::forward(args)...); + } + } else { + return plg::get<1>(storage_).emplace_back(std::forward(args)...); + } + } + + constexpr void pop_back() { + plg::visit([](auto&& vec) { vec.pop_back(); }, storage_); + } + + constexpr void clear() noexcept { + plg::visit([](auto&& vec) { vec.clear(); }, storage_); + } + + // Insert single element (copy) + constexpr auto insert(auto pos, const T& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + return small_vec.insert(pos, value); + } else { + promote_to_heap(); + return plg::get<1>(storage_).insert(pos, value); + } + } else { + return plg::get<1>(storage_).insert(pos, value); + } + } + + // Insert single element (move) + constexpr auto insert(auto pos, T&& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + return small_vec.insert(pos, std::move(value)); + } else { + promote_to_heap(); + return plg::get<1>(storage_).insert(pos, std::move(value)); + } + } else { + return plg::get<1>(storage_).insert(pos, std::move(value)); + } + } + + // Insert count copies + constexpr auto insert(auto pos, size_type count, const T& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() + count <= N) { + return small_vec.insert(pos, count, value); + } else { + promote_to_heap(); + return plg::get<1>(storage_).insert(pos, count, value); + } + } else { + return plg::get<1>(storage_).insert(pos, count, value); + } + } + + // Insert range + template + constexpr auto insert(auto pos, It first, It last) { + if constexpr (std::random_access_iterator) { + auto count = std::distance(first, last); + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() + count <= N) { + return small_vec.insert(pos, first, last); + } else { + promote_to_heap(); + return plg::get<1>(storage_).insert(pos, first, last); + } + } else { + return plg::get<1>(storage_).insert(pos, first, last); + } + } else { + // For non-random-access iterators, insert one by one + auto result = pos; + for (; first != last; ++first) { + result = insert(result, *first); + ++result; + } + return result; + } + } + + // Insert initializer list + constexpr auto insert(auto pos, std::initializer_list ilist) { + return insert(pos, ilist.begin(), ilist.end()); + } + + template + constexpr void append_range(R&& range) { + for (auto&& elem : range) { + push_back(std::forward(elem)); + } + } + + // Append from iterator range + template + constexpr void append(It first, It last) { + for (; first != last; ++first) { + push_back(*first); + } + } + + // Append from initializer list + constexpr void append(std::initializer_list ilist) { + append(ilist.begin(), ilist.end()); + } + + // Erase single element + constexpr auto erase(auto pos) { + return plg::visit([pos](auto&& vec) { return vec.erase(pos); }, storage_); + } + + // Swap contents with another hybrid_vector + constexpr void swap(hybrid_vector& other) noexcept { + storage_.swap(other.storage_); + } + + // Non-member swap for ADL + friend constexpr void swap(hybrid_vector& lhs, hybrid_vector& rhs) noexcept { + lhs.swap(rhs); + } + + // Reserve capacity + constexpr void reserve(size_type new_cap) { + if (new_cap <= N) { + // Stack storage already has capacity N, nothing to do + return; + } + + // Need heap storage for capacity > N + if (is_small()) { + promote_to_heap(); + } + + plg::get<1>(storage_).reserve(new_cap); + } + + // Erase range + constexpr auto erase(auto first, auto last) { + return plg::visit([first, last](auto&& vec) { return vec.erase(first, last); }, storage_); + } + + // Iterators + [[nodiscard]] constexpr auto begin(this auto&& self) { + return plg::visit([](auto&& vec) { return vec.begin(); }, self.storage_); + } + + [[nodiscard]] constexpr auto end(this auto&& self) { + return plg::visit([](auto&& vec) { return vec.end(); }, self.storage_); + } + + [[nodiscard]] constexpr auto cbegin(this auto&& self) { + return plg::visit([](auto&& vec) { return vec.cbegin(); }, self.storage_); + } + + [[nodiscard]] constexpr auto cend(this auto&& self) { + return plg::visit([](auto&& vec) { return vec.cend(); }, self.storage_); + } + + // Range support (C++23) + [[nodiscard]] friend constexpr auto begin(hybrid_vector& v) { + return v.begin(); + } + + [[nodiscard]] friend constexpr auto end(hybrid_vector& v) { + return v.end(); + } + + [[nodiscard]] friend constexpr auto cbegin(hybrid_vector& v) { + return v.cbegin(); + } + + [[nodiscard]] friend constexpr auto cend(hybrid_vector& v) { + return v.cend(); + } + }; +} \ No newline at end of file diff --git a/test/cross_call_master/external/plugify/include/plg/inplace_vector.hpp b/test/cross_call_master/external/plugify/include/plg/inplace_vector.hpp index db59904..5a6d279 100644 --- a/test/cross_call_master/external/plugify/include/plg/inplace_vector.hpp +++ b/test/cross_call_master/external/plugify/include/plg/inplace_vector.hpp @@ -83,7 +83,8 @@ namespace plg { noexcept(std::is_nothrow_copy_constructible_v) { if constexpr (std::is_trivially_copy_constructible_v) { - std::memmove((void*)this, (const void*)std::addressof(rhs), sizeof(ipvbase)); + std::memcpy(data_, rhs.data_, rhs.size_ * sizeof(T)); + size_ = rhs.size_; } else { std::uninitialized_copy_n(rhs.data_, rhs.size_, data_); size_ = rhs.size_; @@ -97,7 +98,8 @@ namespace plg { ) { if constexpr (std::is_trivially_move_constructible_v) { - std::memmove((void*)this, (const void*)std::addressof(rhs), sizeof(ipvbase)); + std::memcpy(data_, rhs.data_, rhs.size_ * sizeof(T)); + size_ = rhs.size_; #if defined(__cpp_lib_trivially_relocatable) } else if constexpr (std::is_trivially_relocatable_v) { std::uninitialized_relocate_n(rhs.data_, rhs.size_, data_); @@ -112,10 +114,11 @@ namespace plg { void operator=(const ipvbase& rhs) noexcept(std::is_nothrow_copy_constructible_v && std::is_nothrow_copy_assignable_v) { + if (this == std::addressof(rhs)) return; + if constexpr (std::is_trivially_copy_constructible_v && std::is_trivially_copy_assignable_v && std::is_trivially_destructible_v) { - std::memmove((void*)this, (const void*)std::addressof(rhs), sizeof(ipvbase)); - } else if (this == std::addressof(rhs)) { - // do nothing + std::memcpy(data_, rhs.data_, rhs.size_ * sizeof(T)); + size_ = rhs.size_; } else if (rhs.size_ <= size_) { std::copy(rhs.data_, rhs.data_ + rhs.size_, data_); std::destroy(data_ + rhs.size_, data_ + size_); @@ -129,10 +132,11 @@ namespace plg { void operator=(ipvbase&& rhs) noexcept(std::is_nothrow_move_constructible_v && std::is_nothrow_move_assignable_v) { + if (this == std::addressof(rhs)) return; + if constexpr (std::is_trivially_move_constructible_v && std::is_trivially_move_assignable_v && std::is_trivially_destructible_v) { - std::memmove((void*)this, (const void*)std::addressof(rhs), sizeof(ipvbase)); - } else if (this == std::addressof(rhs)) { - // do nothing + std::memcpy(data_, rhs.data_, rhs.size_ * sizeof(T)); + size_ = rhs.size_; } else if (rhs.size_ <= size_) { std::move(rhs.data_, rhs.data_ + rhs.size_, data_); std::destroy(data_ + rhs.size_, data_ + size_); diff --git a/test/cross_call_master/external/plugify/include/plg/string.hpp b/test/cross_call_master/external/plugify/include/plg/string.hpp index aaaf3c1..fb63392 100644 --- a/test/cross_call_master/external/plugify/include/plg/string.hpp +++ b/test/cross_call_master/external/plugify/include/plg/string.hpp @@ -2148,18 +2148,34 @@ namespace plg { } constexpr void annotate_new(size_type current_size) const noexcept { + if (!is_long()) { + return; + } + annotate_contiguous_container(data() + capacity() + 1, data() + current_size + 1); } constexpr void annotate_delete() const noexcept { + if (!is_long()) { + return; + } + annotate_contiguous_container(data() + size() + 1, data() + capacity() + 1); } constexpr void annotate_increase(size_type n) const noexcept { + if (!is_long()) { + return; + } + annotate_contiguous_container(data() + size() + 1, data() + size() + 1 + n); } constexpr void annotate_shrink(size_type old_size) const noexcept { + if (!is_long()) { + return; + } + annotate_contiguous_container(data() + old_size + 1, data() + size() + 1); } @@ -3935,7 +3951,7 @@ std::ostream& operator<<(std::ostream& os, const plg::basic_string namespace plg { @@ -4024,4 +4040,4 @@ namespace plg { return result; } } // namespace plugify -#endif // PLUGIFY_STRING_NO_STD_FORMAT \ No newline at end of file +#endif // PLUGIFY_STRING_NO_STD_UTIL diff --git a/test/cross_call_master/external/plugify/include/plg/vector.hpp b/test/cross_call_master/external/plugify/include/plg/vector.hpp index 56884fc..bf562c3 100644 --- a/test/cross_call_master/external/plugify/include/plg/vector.hpp +++ b/test/cross_call_master/external/plugify/include/plg/vector.hpp @@ -1572,3 +1572,81 @@ namespace plg { using vector = ::plg::vector>; } // namespace pmr } // namespace plg + +#ifndef PLUGIFY_VECTOR_NO_STD_UTIL +#include +#include +#include + +namespace plg { + constexpr vector split(std::string_view str, std::string_view delims = " ") { + vector output; + size_t first = 0; + + while (first < str.size()) { + const size_t second = str.find_first_of(delims, first); + + if (first != second) + output.emplace_back(str.substr(first, second - first)); + + if (second == std::string_view::npos) + break; + + first = second + 1; + } + + return output; + } + + template + constexpr std::optional cast_to(std::string_view str) { + T value; + auto [ptr, ec] = std::from_chars(str.data(), str.data() + str.size(), value); + if (ec == std::errc()) { + return value; + } + return std::nullopt; + } + +#if PLUGIFY_PLATFORM_APPLE + template<> + inline std::optional cast_to(std::string_view str) { + std::string p(str); + size_t pos = 0; + try { + double v = std::stod(p, &pos); + if (pos != p.size()) return std::nullopt; + return v; + } catch (...) { + return std::nullopt; + } + } + + template<> + inline std::optional cast_to(std::string_view str) { + std::string p(str); + size_t pos = 0; + try { + float v = std::stof(p, &pos); + if (pos != p.size()) return std::nullopt; + return v; + } catch (...) { + return std::nullopt; + } + } +#endif + + template + constexpr vector parse(std::string_view str, std::string_view delims = " ") { + vector vec; + auto items = split(str, delims); + vec.reserve(items.size()); + for (const auto& item : items) { + if (auto value = cast_to(item)) { + vec.emplace_back(*value); + } + } + return vec; + } +} // namespace plugify +#endif // PLUGIFY_VECTOR_NO_STD_UTIL diff --git a/test/cross_call_worker/external/plugify/include/plg/allocator.hpp b/test/cross_call_worker/external/plugify/include/plg/allocator.hpp index 3bb603d..8cbcbf7 100644 --- a/test/cross_call_worker/external/plugify/include/plg/allocator.hpp +++ b/test/cross_call_worker/external/plugify/include/plg/allocator.hpp @@ -47,7 +47,11 @@ namespace plg { size_type size = n * sizeof(T); if (std::is_constant_evaluated()) { - return static_cast(::operator new(size)); + if constexpr (alignof(T) > alignof(std::max_align_t)) { + return static_cast(::operator new(size, std::align_val_t{alignof(T)})); + } else { + return static_cast(::operator new(size)); + } } else { return malloc_allocate(size); } @@ -55,9 +59,13 @@ namespace plg { constexpr void deallocate(T* p, [[maybe_unused]] size_type n) { if (std::is_constant_evaluated()) { - ::operator delete(p); + if constexpr (alignof(T) > alignof(std::max_align_t)) { + ::operator delete(p, std::align_val_t{alignof(T)}); + } else { + ::operator delete(p); + } } else { - std::free(p); + malloc_deallocate(p); } } @@ -65,8 +73,7 @@ namespace plg { static T* malloc_allocate(size_type size) { T* ret; if constexpr (alignof(T) > alignof(std::max_align_t)) { - size_type aligned_size = (size + (alignof(T) - 1)) & ~(alignof(T) - 1); - ret = static_cast(aligned_allocate(alignof(T), aligned_size)); + ret = static_cast(aligned_allocate(size)); } else { ret = static_cast(std::malloc(size)); } @@ -76,6 +83,14 @@ namespace plg { return ret; } + static void malloc_deallocate(T* ptr) { + if constexpr (alignof(T) > alignof(std::max_align_t)) { + aligned_deallocate(ptr); + } else { + std::free(ptr); + } + } + [[noreturn]] static void throw_bad_array_new_length() { PLUGIFY_THROW("bad array new length", std::bad_array_new_length); } @@ -84,11 +99,20 @@ namespace plg { PLUGIFY_THROW("bad allocation", std::bad_alloc); } - static void* aligned_allocate(size_type alignment, size_type size) { + static void* aligned_allocate(size_type size) { +#if PLUGIFY_PLATFORM_WINDOWS + return _aligned_malloc(size, alignof(T)); +#else + size_type aligned_size = (size + (alignof(T) - 1)) & ~(alignof(T) - 1); + return std::aligned_alloc(alignof(T), aligned_size); +#endif // PLUGIFY_PLATFORM_WINDOWS + } + + static void aligned_deallocate(void* ptr) { #if PLUGIFY_PLATFORM_WINDOWS - return _aligned_malloc(size, alignment); + _aligned_free(ptr); #else - return std::aligned_alloc(alignment, size); + std::free(ptr); #endif // PLUGIFY_PLATFORM_WINDOWS } }; diff --git a/test/cross_call_worker/external/plugify/include/plg/enum.hpp b/test/cross_call_worker/external/plugify/include/plg/enum.hpp index 0692a31..1e159d0 100644 --- a/test/cross_call_worker/external/plugify/include/plg/enum.hpp +++ b/test/cross_call_worker/external/plugify/include/plg/enum.hpp @@ -28,17 +28,16 @@ namespace plg { std::array content_{}; }; - constexpr auto is_pretty(char ch) noexcept { - return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'); - } - constexpr auto pretty_name(std::string_view sv) noexcept { - for (std::size_t n = sv.size() - 1; n > 0; --n) { - if (!is_pretty(sv[n])) { - sv.remove_prefix(n + 1); - break; - } + // Find last non-pretty character from the end + auto pos = sv.find_last_not_of( + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_" + ); + + if (pos != std::string_view::npos) { + sv.remove_prefix(pos + 1); } + return sv; } diff --git a/test/cross_call_worker/external/plugify/include/plg/hash.hpp b/test/cross_call_worker/external/plugify/include/plg/hash.hpp index 982f796..6a20926 100644 --- a/test/cross_call_worker/external/plugify/include/plg/hash.hpp +++ b/test/cross_call_worker/external/plugify/include/plg/hash.hpp @@ -73,6 +73,19 @@ namespace plg { struct case_insensitive_equal { using is_transparent = void; // Enables heterogeneous lookup + template + bool operator()(const T1& lhs, const T2& rhs) const noexcept { + return lhs.size() == rhs.size() && + std::equal(lhs.begin(), lhs.end(), rhs.begin(), + [](const auto& ac, const auto& bc) { + return std::tolower(ac) == std::tolower(bc); + }); + } + }; + + struct case_insensitive_compare { + using is_transparent = void; // Enables heterogeneous lookup + template bool operator()(const T1& lhs, const T2& rhs) const noexcept { return std::lexicographical_compare( @@ -85,8 +98,7 @@ namespace plg { } }; - inline void hash_combine(size_t&) { - } + inline void hash_combine(std::size_t&) {} template inline void hash_combine(std::size_t& seed, const T& v) { @@ -103,7 +115,7 @@ namespace plg { template struct pair_hash { - size_t operator()(const std::pair& p) const { + std::size_t operator()(const std::pair& p) const { return hash_combine_all(p.first, p.second); } }; diff --git a/test/cross_call_worker/external/plugify/include/plg/hybrid_vector.hpp b/test/cross_call_worker/external/plugify/include/plg/hybrid_vector.hpp new file mode 100644 index 0000000..9fe60f0 --- /dev/null +++ b/test/cross_call_worker/external/plugify/include/plg/hybrid_vector.hpp @@ -0,0 +1,335 @@ +#pragma once + +#include "plg/vector.hpp" +#include "plg/inplace_vector.hpp" +#include "plg/variant.hpp" + +namespace plg { + // hybrid container that uses std::inplace_vector for stack storage up to N elements, then switches to std::vector for larger sizes. + template requires (N > 0) + class hybrid_vector { + private: + variant, vector> storage_; + + // Check if currently using stack storage + [[nodiscard]] constexpr bool is_small() const noexcept { + return storage_.index() == 0; + } + + // Promote from stack to heap storage + constexpr void promote_to_heap() { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + vector heap_vec( + std::make_move_iterator(small_vec.begin()), + std::make_move_iterator(small_vec.end()) + ); + storage_.template emplace<1>(std::move(heap_vec)); + } + } + + public: + using value_type = T; + using size_type = std::size_t; + using reference = T&; + using const_reference = const T&; + + // Constructors + constexpr hybrid_vector() noexcept + : storage_(in_place_index<0>) {} + + constexpr explicit hybrid_vector(size_type count) + : storage_(count <= N ? + variant, vector>( + in_place_index<0>, count) : + variant, vector>( + in_place_index<1>, count)) {} + + constexpr hybrid_vector(size_type count, const T& value) + : storage_(count <= N ? + variant, vector>( + in_place_index<0>, count, value) : + variant, vector>( + in_place_index<1>, count, value)) {} + + template + constexpr hybrid_vector(It first, It last) { + if constexpr (std::random_access_iterator) { + auto count = std::distance(first, last); + if (count <= static_cast(N)) { + storage_.template emplace<0>(first, last); + } else { + storage_.template emplace<1>(first, last); + } + } else { + storage_.template emplace<0>(); + for (; first != last; ++first) { + push_back(*first); + } + } + } + + constexpr hybrid_vector(std::initializer_list init) + : hybrid_vector(init.begin(), init.end()) {} + + // Size operations using C++23 explicit object parameter (deducing this) + [[nodiscard]] constexpr size_type size(this auto&& self) noexcept { + return plg::visit([](auto&& vec) { return vec.size(); }, self.storage_); + } + + [[nodiscard]] constexpr size_type capacity(this auto&& self) noexcept { + return plg::visit([](auto&& vec) { return vec.capacity(); }, self.storage_); + } + + [[nodiscard]] constexpr bool empty(this auto&& self) noexcept { + return self.size() == 0; + } + + [[nodiscard]] static constexpr size_type max_stack_size() noexcept { + return N; + } + + // Element access using C++23 explicit object parameter + [[nodiscard]] constexpr reference operator[](this auto&& self, size_type pos) { + return plg::visit([pos](auto&& vec) -> reference { + return vec[pos]; + }, self.storage_); + } + + [[nodiscard]] constexpr reference at(this auto&& self, size_type pos) { + return plg::visit([pos](auto&& vec) -> reference { + return vec.at(pos); + }, self.storage_); + } + + [[nodiscard]] constexpr reference front(this auto&& self) { + return plg::visit([](auto&& vec) -> reference { + return vec.front(); + }, self.storage_); + } + + [[nodiscard]] constexpr reference back(this auto&& self) { + return plg::visit([](auto&& vec) -> reference { + return vec.back(); + }, self.storage_); + } + + // Modifiers + constexpr void push_back(const T& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + small_vec.push_back(value); + } else { + promote_to_heap(); + plg::get<1>(storage_).push_back(value); + } + } else { + plg::get<1>(storage_).push_back(value); + } + } + + constexpr void push_back(T&& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + small_vec.push_back(std::move(value)); + } else { + promote_to_heap(); + plg::get<1>(storage_).push_back(std::move(value)); + } + } else { + plg::get<1>(storage_).push_back(std::move(value)); + } + } + + template + constexpr reference emplace_back(Args&&... args) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + return small_vec.emplace_back(std::forward(args)...); + } else { + promote_to_heap(); + return plg::get<1>(storage_).emplace_back(std::forward(args)...); + } + } else { + return plg::get<1>(storage_).emplace_back(std::forward(args)...); + } + } + + constexpr void pop_back() { + plg::visit([](auto&& vec) { vec.pop_back(); }, storage_); + } + + constexpr void clear() noexcept { + plg::visit([](auto&& vec) { vec.clear(); }, storage_); + } + + // Insert single element (copy) + constexpr auto insert(auto pos, const T& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + return small_vec.insert(pos, value); + } else { + promote_to_heap(); + return plg::get<1>(storage_).insert(pos, value); + } + } else { + return plg::get<1>(storage_).insert(pos, value); + } + } + + // Insert single element (move) + constexpr auto insert(auto pos, T&& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + return small_vec.insert(pos, std::move(value)); + } else { + promote_to_heap(); + return plg::get<1>(storage_).insert(pos, std::move(value)); + } + } else { + return plg::get<1>(storage_).insert(pos, std::move(value)); + } + } + + // Insert count copies + constexpr auto insert(auto pos, size_type count, const T& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() + count <= N) { + return small_vec.insert(pos, count, value); + } else { + promote_to_heap(); + return plg::get<1>(storage_).insert(pos, count, value); + } + } else { + return plg::get<1>(storage_).insert(pos, count, value); + } + } + + // Insert range + template + constexpr auto insert(auto pos, It first, It last) { + if constexpr (std::random_access_iterator) { + auto count = std::distance(first, last); + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() + count <= N) { + return small_vec.insert(pos, first, last); + } else { + promote_to_heap(); + return plg::get<1>(storage_).insert(pos, first, last); + } + } else { + return plg::get<1>(storage_).insert(pos, first, last); + } + } else { + // For non-random-access iterators, insert one by one + auto result = pos; + for (; first != last; ++first) { + result = insert(result, *first); + ++result; + } + return result; + } + } + + // Insert initializer list + constexpr auto insert(auto pos, std::initializer_list ilist) { + return insert(pos, ilist.begin(), ilist.end()); + } + + template + constexpr void append_range(R&& range) { + for (auto&& elem : range) { + push_back(std::forward(elem)); + } + } + + // Append from iterator range + template + constexpr void append(It first, It last) { + for (; first != last; ++first) { + push_back(*first); + } + } + + // Append from initializer list + constexpr void append(std::initializer_list ilist) { + append(ilist.begin(), ilist.end()); + } + + // Erase single element + constexpr auto erase(auto pos) { + return plg::visit([pos](auto&& vec) { return vec.erase(pos); }, storage_); + } + + // Swap contents with another hybrid_vector + constexpr void swap(hybrid_vector& other) noexcept { + storage_.swap(other.storage_); + } + + // Non-member swap for ADL + friend constexpr void swap(hybrid_vector& lhs, hybrid_vector& rhs) noexcept { + lhs.swap(rhs); + } + + // Reserve capacity + constexpr void reserve(size_type new_cap) { + if (new_cap <= N) { + // Stack storage already has capacity N, nothing to do + return; + } + + // Need heap storage for capacity > N + if (is_small()) { + promote_to_heap(); + } + + plg::get<1>(storage_).reserve(new_cap); + } + + // Erase range + constexpr auto erase(auto first, auto last) { + return plg::visit([first, last](auto&& vec) { return vec.erase(first, last); }, storage_); + } + + // Iterators + [[nodiscard]] constexpr auto begin(this auto&& self) { + return plg::visit([](auto&& vec) { return vec.begin(); }, self.storage_); + } + + [[nodiscard]] constexpr auto end(this auto&& self) { + return plg::visit([](auto&& vec) { return vec.end(); }, self.storage_); + } + + [[nodiscard]] constexpr auto cbegin(this auto&& self) { + return plg::visit([](auto&& vec) { return vec.cbegin(); }, self.storage_); + } + + [[nodiscard]] constexpr auto cend(this auto&& self) { + return plg::visit([](auto&& vec) { return vec.cend(); }, self.storage_); + } + + // Range support (C++23) + [[nodiscard]] friend constexpr auto begin(hybrid_vector& v) { + return v.begin(); + } + + [[nodiscard]] friend constexpr auto end(hybrid_vector& v) { + return v.end(); + } + + [[nodiscard]] friend constexpr auto cbegin(hybrid_vector& v) { + return v.cbegin(); + } + + [[nodiscard]] friend constexpr auto cend(hybrid_vector& v) { + return v.cend(); + } + }; +} \ No newline at end of file diff --git a/test/cross_call_worker/external/plugify/include/plg/inplace_vector.hpp b/test/cross_call_worker/external/plugify/include/plg/inplace_vector.hpp index db59904..5a6d279 100644 --- a/test/cross_call_worker/external/plugify/include/plg/inplace_vector.hpp +++ b/test/cross_call_worker/external/plugify/include/plg/inplace_vector.hpp @@ -83,7 +83,8 @@ namespace plg { noexcept(std::is_nothrow_copy_constructible_v) { if constexpr (std::is_trivially_copy_constructible_v) { - std::memmove((void*)this, (const void*)std::addressof(rhs), sizeof(ipvbase)); + std::memcpy(data_, rhs.data_, rhs.size_ * sizeof(T)); + size_ = rhs.size_; } else { std::uninitialized_copy_n(rhs.data_, rhs.size_, data_); size_ = rhs.size_; @@ -97,7 +98,8 @@ namespace plg { ) { if constexpr (std::is_trivially_move_constructible_v) { - std::memmove((void*)this, (const void*)std::addressof(rhs), sizeof(ipvbase)); + std::memcpy(data_, rhs.data_, rhs.size_ * sizeof(T)); + size_ = rhs.size_; #if defined(__cpp_lib_trivially_relocatable) } else if constexpr (std::is_trivially_relocatable_v) { std::uninitialized_relocate_n(rhs.data_, rhs.size_, data_); @@ -112,10 +114,11 @@ namespace plg { void operator=(const ipvbase& rhs) noexcept(std::is_nothrow_copy_constructible_v && std::is_nothrow_copy_assignable_v) { + if (this == std::addressof(rhs)) return; + if constexpr (std::is_trivially_copy_constructible_v && std::is_trivially_copy_assignable_v && std::is_trivially_destructible_v) { - std::memmove((void*)this, (const void*)std::addressof(rhs), sizeof(ipvbase)); - } else if (this == std::addressof(rhs)) { - // do nothing + std::memcpy(data_, rhs.data_, rhs.size_ * sizeof(T)); + size_ = rhs.size_; } else if (rhs.size_ <= size_) { std::copy(rhs.data_, rhs.data_ + rhs.size_, data_); std::destroy(data_ + rhs.size_, data_ + size_); @@ -129,10 +132,11 @@ namespace plg { void operator=(ipvbase&& rhs) noexcept(std::is_nothrow_move_constructible_v && std::is_nothrow_move_assignable_v) { + if (this == std::addressof(rhs)) return; + if constexpr (std::is_trivially_move_constructible_v && std::is_trivially_move_assignable_v && std::is_trivially_destructible_v) { - std::memmove((void*)this, (const void*)std::addressof(rhs), sizeof(ipvbase)); - } else if (this == std::addressof(rhs)) { - // do nothing + std::memcpy(data_, rhs.data_, rhs.size_ * sizeof(T)); + size_ = rhs.size_; } else if (rhs.size_ <= size_) { std::move(rhs.data_, rhs.data_ + rhs.size_, data_); std::destroy(data_ + rhs.size_, data_ + size_); diff --git a/test/cross_call_worker/external/plugify/include/plg/string.hpp b/test/cross_call_worker/external/plugify/include/plg/string.hpp index aaaf3c1..fb63392 100644 --- a/test/cross_call_worker/external/plugify/include/plg/string.hpp +++ b/test/cross_call_worker/external/plugify/include/plg/string.hpp @@ -2148,18 +2148,34 @@ namespace plg { } constexpr void annotate_new(size_type current_size) const noexcept { + if (!is_long()) { + return; + } + annotate_contiguous_container(data() + capacity() + 1, data() + current_size + 1); } constexpr void annotate_delete() const noexcept { + if (!is_long()) { + return; + } + annotate_contiguous_container(data() + size() + 1, data() + capacity() + 1); } constexpr void annotate_increase(size_type n) const noexcept { + if (!is_long()) { + return; + } + annotate_contiguous_container(data() + size() + 1, data() + size() + 1 + n); } constexpr void annotate_shrink(size_type old_size) const noexcept { + if (!is_long()) { + return; + } + annotate_contiguous_container(data() + old_size + 1, data() + size() + 1); } @@ -3935,7 +3951,7 @@ std::ostream& operator<<(std::ostream& os, const plg::basic_string namespace plg { @@ -4024,4 +4040,4 @@ namespace plg { return result; } } // namespace plugify -#endif // PLUGIFY_STRING_NO_STD_FORMAT \ No newline at end of file +#endif // PLUGIFY_STRING_NO_STD_UTIL diff --git a/test/cross_call_worker/external/plugify/include/plg/vector.hpp b/test/cross_call_worker/external/plugify/include/plg/vector.hpp index 56884fc..bf562c3 100644 --- a/test/cross_call_worker/external/plugify/include/plg/vector.hpp +++ b/test/cross_call_worker/external/plugify/include/plg/vector.hpp @@ -1572,3 +1572,81 @@ namespace plg { using vector = ::plg::vector>; } // namespace pmr } // namespace plg + +#ifndef PLUGIFY_VECTOR_NO_STD_UTIL +#include +#include +#include + +namespace plg { + constexpr vector split(std::string_view str, std::string_view delims = " ") { + vector output; + size_t first = 0; + + while (first < str.size()) { + const size_t second = str.find_first_of(delims, first); + + if (first != second) + output.emplace_back(str.substr(first, second - first)); + + if (second == std::string_view::npos) + break; + + first = second + 1; + } + + return output; + } + + template + constexpr std::optional cast_to(std::string_view str) { + T value; + auto [ptr, ec] = std::from_chars(str.data(), str.data() + str.size(), value); + if (ec == std::errc()) { + return value; + } + return std::nullopt; + } + +#if PLUGIFY_PLATFORM_APPLE + template<> + inline std::optional cast_to(std::string_view str) { + std::string p(str); + size_t pos = 0; + try { + double v = std::stod(p, &pos); + if (pos != p.size()) return std::nullopt; + return v; + } catch (...) { + return std::nullopt; + } + } + + template<> + inline std::optional cast_to(std::string_view str) { + std::string p(str); + size_t pos = 0; + try { + float v = std::stof(p, &pos); + if (pos != p.size()) return std::nullopt; + return v; + } catch (...) { + return std::nullopt; + } + } +#endif + + template + constexpr vector parse(std::string_view str, std::string_view delims = " ") { + vector vec; + auto items = split(str, delims); + vec.reserve(items.size()); + for (const auto& item : items) { + if (auto value = cast_to(item)) { + vec.emplace_back(*value); + } + } + return vec; + } +} // namespace plugify +#endif // PLUGIFY_VECTOR_NO_STD_UTIL diff --git a/test/example_plugin/external/plugify/include/plg/allocator.hpp b/test/example_plugin/external/plugify/include/plg/allocator.hpp index 3bb603d..8cbcbf7 100644 --- a/test/example_plugin/external/plugify/include/plg/allocator.hpp +++ b/test/example_plugin/external/plugify/include/plg/allocator.hpp @@ -47,7 +47,11 @@ namespace plg { size_type size = n * sizeof(T); if (std::is_constant_evaluated()) { - return static_cast(::operator new(size)); + if constexpr (alignof(T) > alignof(std::max_align_t)) { + return static_cast(::operator new(size, std::align_val_t{alignof(T)})); + } else { + return static_cast(::operator new(size)); + } } else { return malloc_allocate(size); } @@ -55,9 +59,13 @@ namespace plg { constexpr void deallocate(T* p, [[maybe_unused]] size_type n) { if (std::is_constant_evaluated()) { - ::operator delete(p); + if constexpr (alignof(T) > alignof(std::max_align_t)) { + ::operator delete(p, std::align_val_t{alignof(T)}); + } else { + ::operator delete(p); + } } else { - std::free(p); + malloc_deallocate(p); } } @@ -65,8 +73,7 @@ namespace plg { static T* malloc_allocate(size_type size) { T* ret; if constexpr (alignof(T) > alignof(std::max_align_t)) { - size_type aligned_size = (size + (alignof(T) - 1)) & ~(alignof(T) - 1); - ret = static_cast(aligned_allocate(alignof(T), aligned_size)); + ret = static_cast(aligned_allocate(size)); } else { ret = static_cast(std::malloc(size)); } @@ -76,6 +83,14 @@ namespace plg { return ret; } + static void malloc_deallocate(T* ptr) { + if constexpr (alignof(T) > alignof(std::max_align_t)) { + aligned_deallocate(ptr); + } else { + std::free(ptr); + } + } + [[noreturn]] static void throw_bad_array_new_length() { PLUGIFY_THROW("bad array new length", std::bad_array_new_length); } @@ -84,11 +99,20 @@ namespace plg { PLUGIFY_THROW("bad allocation", std::bad_alloc); } - static void* aligned_allocate(size_type alignment, size_type size) { + static void* aligned_allocate(size_type size) { +#if PLUGIFY_PLATFORM_WINDOWS + return _aligned_malloc(size, alignof(T)); +#else + size_type aligned_size = (size + (alignof(T) - 1)) & ~(alignof(T) - 1); + return std::aligned_alloc(alignof(T), aligned_size); +#endif // PLUGIFY_PLATFORM_WINDOWS + } + + static void aligned_deallocate(void* ptr) { #if PLUGIFY_PLATFORM_WINDOWS - return _aligned_malloc(size, alignment); + _aligned_free(ptr); #else - return std::aligned_alloc(alignment, size); + std::free(ptr); #endif // PLUGIFY_PLATFORM_WINDOWS } }; diff --git a/test/example_plugin/external/plugify/include/plg/enum.hpp b/test/example_plugin/external/plugify/include/plg/enum.hpp index 0692a31..1e159d0 100644 --- a/test/example_plugin/external/plugify/include/plg/enum.hpp +++ b/test/example_plugin/external/plugify/include/plg/enum.hpp @@ -28,17 +28,16 @@ namespace plg { std::array content_{}; }; - constexpr auto is_pretty(char ch) noexcept { - return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'); - } - constexpr auto pretty_name(std::string_view sv) noexcept { - for (std::size_t n = sv.size() - 1; n > 0; --n) { - if (!is_pretty(sv[n])) { - sv.remove_prefix(n + 1); - break; - } + // Find last non-pretty character from the end + auto pos = sv.find_last_not_of( + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_" + ); + + if (pos != std::string_view::npos) { + sv.remove_prefix(pos + 1); } + return sv; } diff --git a/test/example_plugin/external/plugify/include/plg/hash.hpp b/test/example_plugin/external/plugify/include/plg/hash.hpp index 982f796..6a20926 100644 --- a/test/example_plugin/external/plugify/include/plg/hash.hpp +++ b/test/example_plugin/external/plugify/include/plg/hash.hpp @@ -73,6 +73,19 @@ namespace plg { struct case_insensitive_equal { using is_transparent = void; // Enables heterogeneous lookup + template + bool operator()(const T1& lhs, const T2& rhs) const noexcept { + return lhs.size() == rhs.size() && + std::equal(lhs.begin(), lhs.end(), rhs.begin(), + [](const auto& ac, const auto& bc) { + return std::tolower(ac) == std::tolower(bc); + }); + } + }; + + struct case_insensitive_compare { + using is_transparent = void; // Enables heterogeneous lookup + template bool operator()(const T1& lhs, const T2& rhs) const noexcept { return std::lexicographical_compare( @@ -85,8 +98,7 @@ namespace plg { } }; - inline void hash_combine(size_t&) { - } + inline void hash_combine(std::size_t&) {} template inline void hash_combine(std::size_t& seed, const T& v) { @@ -103,7 +115,7 @@ namespace plg { template struct pair_hash { - size_t operator()(const std::pair& p) const { + std::size_t operator()(const std::pair& p) const { return hash_combine_all(p.first, p.second); } }; diff --git a/test/example_plugin/external/plugify/include/plg/hybrid_vector.hpp b/test/example_plugin/external/plugify/include/plg/hybrid_vector.hpp new file mode 100644 index 0000000..9fe60f0 --- /dev/null +++ b/test/example_plugin/external/plugify/include/plg/hybrid_vector.hpp @@ -0,0 +1,335 @@ +#pragma once + +#include "plg/vector.hpp" +#include "plg/inplace_vector.hpp" +#include "plg/variant.hpp" + +namespace plg { + // hybrid container that uses std::inplace_vector for stack storage up to N elements, then switches to std::vector for larger sizes. + template requires (N > 0) + class hybrid_vector { + private: + variant, vector> storage_; + + // Check if currently using stack storage + [[nodiscard]] constexpr bool is_small() const noexcept { + return storage_.index() == 0; + } + + // Promote from stack to heap storage + constexpr void promote_to_heap() { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + vector heap_vec( + std::make_move_iterator(small_vec.begin()), + std::make_move_iterator(small_vec.end()) + ); + storage_.template emplace<1>(std::move(heap_vec)); + } + } + + public: + using value_type = T; + using size_type = std::size_t; + using reference = T&; + using const_reference = const T&; + + // Constructors + constexpr hybrid_vector() noexcept + : storage_(in_place_index<0>) {} + + constexpr explicit hybrid_vector(size_type count) + : storage_(count <= N ? + variant, vector>( + in_place_index<0>, count) : + variant, vector>( + in_place_index<1>, count)) {} + + constexpr hybrid_vector(size_type count, const T& value) + : storage_(count <= N ? + variant, vector>( + in_place_index<0>, count, value) : + variant, vector>( + in_place_index<1>, count, value)) {} + + template + constexpr hybrid_vector(It first, It last) { + if constexpr (std::random_access_iterator) { + auto count = std::distance(first, last); + if (count <= static_cast(N)) { + storage_.template emplace<0>(first, last); + } else { + storage_.template emplace<1>(first, last); + } + } else { + storage_.template emplace<0>(); + for (; first != last; ++first) { + push_back(*first); + } + } + } + + constexpr hybrid_vector(std::initializer_list init) + : hybrid_vector(init.begin(), init.end()) {} + + // Size operations using C++23 explicit object parameter (deducing this) + [[nodiscard]] constexpr size_type size(this auto&& self) noexcept { + return plg::visit([](auto&& vec) { return vec.size(); }, self.storage_); + } + + [[nodiscard]] constexpr size_type capacity(this auto&& self) noexcept { + return plg::visit([](auto&& vec) { return vec.capacity(); }, self.storage_); + } + + [[nodiscard]] constexpr bool empty(this auto&& self) noexcept { + return self.size() == 0; + } + + [[nodiscard]] static constexpr size_type max_stack_size() noexcept { + return N; + } + + // Element access using C++23 explicit object parameter + [[nodiscard]] constexpr reference operator[](this auto&& self, size_type pos) { + return plg::visit([pos](auto&& vec) -> reference { + return vec[pos]; + }, self.storage_); + } + + [[nodiscard]] constexpr reference at(this auto&& self, size_type pos) { + return plg::visit([pos](auto&& vec) -> reference { + return vec.at(pos); + }, self.storage_); + } + + [[nodiscard]] constexpr reference front(this auto&& self) { + return plg::visit([](auto&& vec) -> reference { + return vec.front(); + }, self.storage_); + } + + [[nodiscard]] constexpr reference back(this auto&& self) { + return plg::visit([](auto&& vec) -> reference { + return vec.back(); + }, self.storage_); + } + + // Modifiers + constexpr void push_back(const T& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + small_vec.push_back(value); + } else { + promote_to_heap(); + plg::get<1>(storage_).push_back(value); + } + } else { + plg::get<1>(storage_).push_back(value); + } + } + + constexpr void push_back(T&& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + small_vec.push_back(std::move(value)); + } else { + promote_to_heap(); + plg::get<1>(storage_).push_back(std::move(value)); + } + } else { + plg::get<1>(storage_).push_back(std::move(value)); + } + } + + template + constexpr reference emplace_back(Args&&... args) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + return small_vec.emplace_back(std::forward(args)...); + } else { + promote_to_heap(); + return plg::get<1>(storage_).emplace_back(std::forward(args)...); + } + } else { + return plg::get<1>(storage_).emplace_back(std::forward(args)...); + } + } + + constexpr void pop_back() { + plg::visit([](auto&& vec) { vec.pop_back(); }, storage_); + } + + constexpr void clear() noexcept { + plg::visit([](auto&& vec) { vec.clear(); }, storage_); + } + + // Insert single element (copy) + constexpr auto insert(auto pos, const T& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + return small_vec.insert(pos, value); + } else { + promote_to_heap(); + return plg::get<1>(storage_).insert(pos, value); + } + } else { + return plg::get<1>(storage_).insert(pos, value); + } + } + + // Insert single element (move) + constexpr auto insert(auto pos, T&& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() < N) { + return small_vec.insert(pos, std::move(value)); + } else { + promote_to_heap(); + return plg::get<1>(storage_).insert(pos, std::move(value)); + } + } else { + return plg::get<1>(storage_).insert(pos, std::move(value)); + } + } + + // Insert count copies + constexpr auto insert(auto pos, size_type count, const T& value) { + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() + count <= N) { + return small_vec.insert(pos, count, value); + } else { + promote_to_heap(); + return plg::get<1>(storage_).insert(pos, count, value); + } + } else { + return plg::get<1>(storage_).insert(pos, count, value); + } + } + + // Insert range + template + constexpr auto insert(auto pos, It first, It last) { + if constexpr (std::random_access_iterator) { + auto count = std::distance(first, last); + if (is_small()) { + auto& small_vec = plg::get<0>(storage_); + if (small_vec.size() + count <= N) { + return small_vec.insert(pos, first, last); + } else { + promote_to_heap(); + return plg::get<1>(storage_).insert(pos, first, last); + } + } else { + return plg::get<1>(storage_).insert(pos, first, last); + } + } else { + // For non-random-access iterators, insert one by one + auto result = pos; + for (; first != last; ++first) { + result = insert(result, *first); + ++result; + } + return result; + } + } + + // Insert initializer list + constexpr auto insert(auto pos, std::initializer_list ilist) { + return insert(pos, ilist.begin(), ilist.end()); + } + + template + constexpr void append_range(R&& range) { + for (auto&& elem : range) { + push_back(std::forward(elem)); + } + } + + // Append from iterator range + template + constexpr void append(It first, It last) { + for (; first != last; ++first) { + push_back(*first); + } + } + + // Append from initializer list + constexpr void append(std::initializer_list ilist) { + append(ilist.begin(), ilist.end()); + } + + // Erase single element + constexpr auto erase(auto pos) { + return plg::visit([pos](auto&& vec) { return vec.erase(pos); }, storage_); + } + + // Swap contents with another hybrid_vector + constexpr void swap(hybrid_vector& other) noexcept { + storage_.swap(other.storage_); + } + + // Non-member swap for ADL + friend constexpr void swap(hybrid_vector& lhs, hybrid_vector& rhs) noexcept { + lhs.swap(rhs); + } + + // Reserve capacity + constexpr void reserve(size_type new_cap) { + if (new_cap <= N) { + // Stack storage already has capacity N, nothing to do + return; + } + + // Need heap storage for capacity > N + if (is_small()) { + promote_to_heap(); + } + + plg::get<1>(storage_).reserve(new_cap); + } + + // Erase range + constexpr auto erase(auto first, auto last) { + return plg::visit([first, last](auto&& vec) { return vec.erase(first, last); }, storage_); + } + + // Iterators + [[nodiscard]] constexpr auto begin(this auto&& self) { + return plg::visit([](auto&& vec) { return vec.begin(); }, self.storage_); + } + + [[nodiscard]] constexpr auto end(this auto&& self) { + return plg::visit([](auto&& vec) { return vec.end(); }, self.storage_); + } + + [[nodiscard]] constexpr auto cbegin(this auto&& self) { + return plg::visit([](auto&& vec) { return vec.cbegin(); }, self.storage_); + } + + [[nodiscard]] constexpr auto cend(this auto&& self) { + return plg::visit([](auto&& vec) { return vec.cend(); }, self.storage_); + } + + // Range support (C++23) + [[nodiscard]] friend constexpr auto begin(hybrid_vector& v) { + return v.begin(); + } + + [[nodiscard]] friend constexpr auto end(hybrid_vector& v) { + return v.end(); + } + + [[nodiscard]] friend constexpr auto cbegin(hybrid_vector& v) { + return v.cbegin(); + } + + [[nodiscard]] friend constexpr auto cend(hybrid_vector& v) { + return v.cend(); + } + }; +} \ No newline at end of file diff --git a/test/example_plugin/external/plugify/include/plg/inplace_vector.hpp b/test/example_plugin/external/plugify/include/plg/inplace_vector.hpp index db59904..5a6d279 100644 --- a/test/example_plugin/external/plugify/include/plg/inplace_vector.hpp +++ b/test/example_plugin/external/plugify/include/plg/inplace_vector.hpp @@ -83,7 +83,8 @@ namespace plg { noexcept(std::is_nothrow_copy_constructible_v) { if constexpr (std::is_trivially_copy_constructible_v) { - std::memmove((void*)this, (const void*)std::addressof(rhs), sizeof(ipvbase)); + std::memcpy(data_, rhs.data_, rhs.size_ * sizeof(T)); + size_ = rhs.size_; } else { std::uninitialized_copy_n(rhs.data_, rhs.size_, data_); size_ = rhs.size_; @@ -97,7 +98,8 @@ namespace plg { ) { if constexpr (std::is_trivially_move_constructible_v) { - std::memmove((void*)this, (const void*)std::addressof(rhs), sizeof(ipvbase)); + std::memcpy(data_, rhs.data_, rhs.size_ * sizeof(T)); + size_ = rhs.size_; #if defined(__cpp_lib_trivially_relocatable) } else if constexpr (std::is_trivially_relocatable_v) { std::uninitialized_relocate_n(rhs.data_, rhs.size_, data_); @@ -112,10 +114,11 @@ namespace plg { void operator=(const ipvbase& rhs) noexcept(std::is_nothrow_copy_constructible_v && std::is_nothrow_copy_assignable_v) { + if (this == std::addressof(rhs)) return; + if constexpr (std::is_trivially_copy_constructible_v && std::is_trivially_copy_assignable_v && std::is_trivially_destructible_v) { - std::memmove((void*)this, (const void*)std::addressof(rhs), sizeof(ipvbase)); - } else if (this == std::addressof(rhs)) { - // do nothing + std::memcpy(data_, rhs.data_, rhs.size_ * sizeof(T)); + size_ = rhs.size_; } else if (rhs.size_ <= size_) { std::copy(rhs.data_, rhs.data_ + rhs.size_, data_); std::destroy(data_ + rhs.size_, data_ + size_); @@ -129,10 +132,11 @@ namespace plg { void operator=(ipvbase&& rhs) noexcept(std::is_nothrow_move_constructible_v && std::is_nothrow_move_assignable_v) { + if (this == std::addressof(rhs)) return; + if constexpr (std::is_trivially_move_constructible_v && std::is_trivially_move_assignable_v && std::is_trivially_destructible_v) { - std::memmove((void*)this, (const void*)std::addressof(rhs), sizeof(ipvbase)); - } else if (this == std::addressof(rhs)) { - // do nothing + std::memcpy(data_, rhs.data_, rhs.size_ * sizeof(T)); + size_ = rhs.size_; } else if (rhs.size_ <= size_) { std::move(rhs.data_, rhs.data_ + rhs.size_, data_); std::destroy(data_ + rhs.size_, data_ + size_); diff --git a/test/example_plugin/external/plugify/include/plg/string.hpp b/test/example_plugin/external/plugify/include/plg/string.hpp index aaaf3c1..fb63392 100644 --- a/test/example_plugin/external/plugify/include/plg/string.hpp +++ b/test/example_plugin/external/plugify/include/plg/string.hpp @@ -2148,18 +2148,34 @@ namespace plg { } constexpr void annotate_new(size_type current_size) const noexcept { + if (!is_long()) { + return; + } + annotate_contiguous_container(data() + capacity() + 1, data() + current_size + 1); } constexpr void annotate_delete() const noexcept { + if (!is_long()) { + return; + } + annotate_contiguous_container(data() + size() + 1, data() + capacity() + 1); } constexpr void annotate_increase(size_type n) const noexcept { + if (!is_long()) { + return; + } + annotate_contiguous_container(data() + size() + 1, data() + size() + 1 + n); } constexpr void annotate_shrink(size_type old_size) const noexcept { + if (!is_long()) { + return; + } + annotate_contiguous_container(data() + old_size + 1, data() + size() + 1); } @@ -3935,7 +3951,7 @@ std::ostream& operator<<(std::ostream& os, const plg::basic_string namespace plg { @@ -4024,4 +4040,4 @@ namespace plg { return result; } } // namespace plugify -#endif // PLUGIFY_STRING_NO_STD_FORMAT \ No newline at end of file +#endif // PLUGIFY_STRING_NO_STD_UTIL diff --git a/test/example_plugin/external/plugify/include/plg/vector.hpp b/test/example_plugin/external/plugify/include/plg/vector.hpp index 56884fc..bf562c3 100644 --- a/test/example_plugin/external/plugify/include/plg/vector.hpp +++ b/test/example_plugin/external/plugify/include/plg/vector.hpp @@ -1572,3 +1572,81 @@ namespace plg { using vector = ::plg::vector>; } // namespace pmr } // namespace plg + +#ifndef PLUGIFY_VECTOR_NO_STD_UTIL +#include +#include +#include + +namespace plg { + constexpr vector split(std::string_view str, std::string_view delims = " ") { + vector output; + size_t first = 0; + + while (first < str.size()) { + const size_t second = str.find_first_of(delims, first); + + if (first != second) + output.emplace_back(str.substr(first, second - first)); + + if (second == std::string_view::npos) + break; + + first = second + 1; + } + + return output; + } + + template + constexpr std::optional cast_to(std::string_view str) { + T value; + auto [ptr, ec] = std::from_chars(str.data(), str.data() + str.size(), value); + if (ec == std::errc()) { + return value; + } + return std::nullopt; + } + +#if PLUGIFY_PLATFORM_APPLE + template<> + inline std::optional cast_to(std::string_view str) { + std::string p(str); + size_t pos = 0; + try { + double v = std::stod(p, &pos); + if (pos != p.size()) return std::nullopt; + return v; + } catch (...) { + return std::nullopt; + } + } + + template<> + inline std::optional cast_to(std::string_view str) { + std::string p(str); + size_t pos = 0; + try { + float v = std::stof(p, &pos); + if (pos != p.size()) return std::nullopt; + return v; + } catch (...) { + return std::nullopt; + } + } +#endif + + template + constexpr vector parse(std::string_view str, std::string_view delims = " ") { + vector vec; + auto items = split(str, delims); + vec.reserve(items.size()); + for (const auto& item : items) { + if (auto value = cast_to(item)) { + vec.emplace_back(*value); + } + } + return vec; + } +} // namespace plugify +#endif // PLUGIFY_VECTOR_NO_STD_UTIL From e5330e39c0223315cf732aa94aff9fa54b54a0c7 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sat, 13 Dec 2025 14:46:19 +0000 Subject: [PATCH 6/6] chore(main): release 2.2.0 --- .github/release-please-manifest.json | 2 +- CHANGELOG.md | 14 ++++++++++++++ version.txt | 2 +- 3 files changed, 16 insertions(+), 2 deletions(-) diff --git a/.github/release-please-manifest.json b/.github/release-please-manifest.json index 5c6af54..a5d1cf2 100644 --- a/.github/release-please-manifest.json +++ b/.github/release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "2.1.5" + ".": "2.2.0" } diff --git a/CHANGELOG.md b/CHANGELOG.md index 5689741..2d95818 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,19 @@ # Changelog +## [2.2.0](https://github.com/untrustedmodders/plugify-module-cpp/compare/v2.1.5...v2.2.0) (2025-12-13) + + +### Features + +* rework native system ([4fa9ff2](https://github.com/untrustedmodders/plugify-module-cpp/commit/4fa9ff2ac29e1d276dffe800369c461bf43f358d)) + + +### Bug Fixes + +* add try catch to legacy parser ([de5c457](https://github.com/untrustedmodders/plugify-module-cpp/commit/de5c457ef1edf1fadb9e73c58efd0da79bf29a02)) +* update plugify ([ddb7712](https://github.com/untrustedmodders/plugify-module-cpp/commit/ddb771255bb06c3b85b2325c238a1b8374dad33f)) +* update tests ([ab8aa81](https://github.com/untrustedmodders/plugify-module-cpp/commit/ab8aa8168b8c981aa54cd38f7a95c6cdc4b04777)) + ## [2.1.5](https://github.com/untrustedmodders/plugify-module-cpp/compare/v2.1.4...v2.1.5) (2025-11-27) diff --git a/version.txt b/version.txt index cd57a8b..ccbccc3 100644 --- a/version.txt +++ b/version.txt @@ -1 +1 @@ -2.1.5 +2.2.0