diff --git a/.github/release-please-manifest.json b/.github/release-please-manifest.json index 2e9c48c..b83b80e 100644 --- a/.github/release-please-manifest.json +++ b/.github/release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "2.0.5" + ".": "2.0.6" } diff --git a/.github/workflows/cmake-multiple-platform.yml b/.github/workflows/cmake-multiple-platform.yml index 33136f7..cad525a 100644 --- a/.github/workflows/cmake-multiple-platform.yml +++ b/.github/workflows/cmake-multiple-platform.yml @@ -415,26 +415,31 @@ jobs: runs-on: ubuntu-latest steps: - name: Send Discord Notification - if: ${{ success() }} - env: - DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }} - uses: Ilshidur/action-discord@0.3.2 + if: ${{ needs.build.result == 'success' && needs.package.result == 'success' && needs.repository.result == 'success' }} + uses: tsickert/discord-webhook@v7.0.0 with: - args: | - 🎉 **New Release: ${{ env.PROJECT_NAME }} ${{ needs.setup.outputs.tag_name }}** + webhook-url: ${{ secrets.DISCORD_WEBHOOK }} + embed-description: | + ## <:plugin_creator:1336096248515657880> New Release: ${{ env.PROJECT_NAME }} ${{ needs.setup.outputs.tag_name }} + + ### <:link:1342486300653129811> Downloads + -# <:curved_arrow_right:1342544469148565545> [${{ needs.setup.outputs.tag_name }}](${{ needs.package.outputs.url }}) - 📦 **Downloads:** [${{ needs.setup.outputs.tag_name }}](${{ needs.package.outputs.url }}) - 🐍 **Conda Channel:** https://${{ github.repository_owner }}.github.io/${{ github.event.repository.name }}/ + ### 🐍 Conda Channel + -# <:curved_arrow_right:1342544469148565545> https://${{ github.repository_owner }}.github.io/${{ github.event.repository.name }}/ - Install via conda: + <:blank:1335697913464098908> + **Install via conda:** ```bash conda install -c https://${{ github.repository_owner }}.github.io/${{ github.event.repository.name }}/ ${{ env.PROJECT_NAME }} ``` - + embed-color: 955135 + - name: Send Failure Notification - if: ${{ failure() }} - env: - DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }} - uses: Ilshidur/action-discord@0.3.2 + if: ${{ needs.build.result == 'failure' || needs.package.result == 'failure' || needs.repository.result == 'failure' }} + uses: tsickert/discord-webhook@v7.0.0 with: - args: "⚠️ Release workflow failed for ${{ env.PROJECT_NAME }} ${{ needs.setup.outputs.tag_name }}" + webhook-url: ${{ secrets.DISCORD_WEBHOOK }} + embed-description: | + ## Release workflow failed for ${{ env.PROJECT_NAME }} ${{ needs.setup.outputs.tag_name }} + embed-color: 16221227 diff --git a/CHANGELOG.md b/CHANGELOG.md index c67b295..f43946a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,16 @@ # Changelog +## [2.0.6](https://github.com/untrustedmodders/plugify-module-golang/compare/v2.0.5...v2.0.6) (2025-11-26) + + +### Bug Fixes + +* add new class tests ([7fb8656](https://github.com/untrustedmodders/plugify-module-golang/commit/7fb8656a0c63d2d2746aa9aae1f6cdda0d10c1df)) +* some improvements for test ([2cdcc38](https://github.com/untrustedmodders/plugify-module-golang/commit/2cdcc3859683b371b2528d347403b0aebf85df1c)) +* update deps ([49afe72](https://github.com/untrustedmodders/plugify-module-golang/commit/49afe7271ddaf67a91fe8407a1583fd729785329)) +* update deps ([0b6d7ad](https://github.com/untrustedmodders/plugify-module-golang/commit/0b6d7ad64786eb3aec2c8195e70a6f3ace9be88e)) +* update notify ([ef25c62](https://github.com/untrustedmodders/plugify-module-golang/commit/ef25c627f4541293b09aa76c6e57f5666bca6baa)) + ## [2.0.5](https://github.com/untrustedmodders/plugify-module-golang/compare/v2.0.4...v2.0.5) (2025-10-06) diff --git a/external/plugify b/external/plugify index df3298e..d55fb6b 160000 --- a/external/plugify +++ b/external/plugify @@ -1 +1 @@ -Subproject commit df3298ef363adec30bb621004cebd4f0ebd9ee19 +Subproject commit d55fb6b3b88470de1b60ca558b60c91b05e0f78c diff --git a/test/cross_call_worker/autoexports.go b/test/cross_call_worker/autoexports.go index 468685c..967a1e6 100644 --- a/test/cross_call_worker/autoexports.go +++ b/test/cross_call_worker/autoexports.go @@ -3,9 +3,13 @@ package main // #include "autoexports.h" import "C" import ( - "github.com/untrustedmodders/go-plugify" "reflect" + _ "reflect" "unsafe" + _ "unsafe" + + "github.com/untrustedmodders/go-plugify" + _ "github.com/untrustedmodders/go-plugify" ) // Exported methods @@ -129,14 +133,14 @@ func __NoParamReturnArrayBool() C.Vector { //export __NoParamReturnArrayChar8 func __NoParamReturnArrayChar8() C.Vector { __result := NoParamReturnArrayChar8() - __return := plugify.ConstructVectorChar8(__result) + __return := plugify.ConstructVectorInt8(__result) return *(*C.Vector)(unsafe.Pointer(&__return)) } //export __NoParamReturnArrayChar16 func __NoParamReturnArrayChar16() C.Vector { __result := NoParamReturnArrayChar16() - __return := plugify.ConstructVectorChar16(__result) + __return := plugify.ConstructVectorUInt16(__result) return *(*C.Vector)(unsafe.Pointer(&__return)) } @@ -406,8 +410,8 @@ func __ParamRef10(a *int32, b *float32, c *float64, d *C.Vector4, e *C.Vector, f //export __ParamRefVectors func __ParamRefVectors(p1 *C.Vector, p2 *C.Vector, p3 *C.Vector, p4 *C.Vector, p5 *C.Vector, p6 *C.Vector, p7 *C.Vector, p8 *C.Vector, p9 *C.Vector, p10 *C.Vector, p11 *C.Vector, p12 *C.Vector, p13 *C.Vector, p14 *C.Vector, p15 *C.Vector) { _p1 := plugify.GetVectorDataBool((*plugify.PlgVector)(unsafe.Pointer(p1))) - _p2 := plugify.GetVectorDataChar8((*plugify.PlgVector)(unsafe.Pointer(p2))) - _p3 := plugify.GetVectorDataChar16((*plugify.PlgVector)(unsafe.Pointer(p3))) + _p2 := plugify.GetVectorDataInt8((*plugify.PlgVector)(unsafe.Pointer(p2))) + _p3 := plugify.GetVectorDataUInt16((*plugify.PlgVector)(unsafe.Pointer(p3))) _p4 := plugify.GetVectorDataInt8((*plugify.PlgVector)(unsafe.Pointer(p4))) _p5 := plugify.GetVectorDataInt16((*plugify.PlgVector)(unsafe.Pointer(p5))) _p6 := plugify.GetVectorDataInt32((*plugify.PlgVector)(unsafe.Pointer(p6))) @@ -422,8 +426,8 @@ func __ParamRefVectors(p1 *C.Vector, p2 *C.Vector, p3 *C.Vector, p4 *C.Vector, p _p15 := plugify.GetVectorDataString((*plugify.PlgVector)(unsafe.Pointer(p15))) ParamRefVectors(&_p1, &_p2, &_p3, &_p4, &_p5, &_p6, &_p7, &_p8, &_p9, &_p10, &_p11, &_p12, &_p13, &_p14, &_p15) plugify.AssignVectorBool((*plugify.PlgVector)(unsafe.Pointer(p1)), _p1) - plugify.AssignVectorChar8((*plugify.PlgVector)(unsafe.Pointer(p2)), _p2) - plugify.AssignVectorChar16((*plugify.PlgVector)(unsafe.Pointer(p3)), _p3) + plugify.AssignVectorInt8((*plugify.PlgVector)(unsafe.Pointer(p2)), _p2) + plugify.AssignVectorUInt16((*plugify.PlgVector)(unsafe.Pointer(p3)), _p3) plugify.AssignVectorInt8((*plugify.PlgVector)(unsafe.Pointer(p4)), _p4) plugify.AssignVectorInt16((*plugify.PlgVector)(unsafe.Pointer(p5)), _p5) plugify.AssignVectorInt32((*plugify.PlgVector)(unsafe.Pointer(p6)), _p6) @@ -444,11 +448,6 @@ func __ParamAllPrimitives(p1 bool, p2 int8, p3 uint16, p4 int8, p5 int16, p6 int return __result } -//export __ParamVariant -func __ParamVariant(p1 *C.Variant, p2 *C.Vector) { - ParamVariant(plugify.GetVariantData((*plugify.PlgVariant)(unsafe.Pointer(p1))), plugify.GetVectorDataVariant((*plugify.PlgVector)(unsafe.Pointer(p2)))) -} - //export __ParamEnum func __ParamEnum(p1 int32, p2 *C.Vector) int32 { __result := ParamEnum(Example(p1), plugify.GetVectorDataInt32T[Example]((*plugify.PlgVector)(unsafe.Pointer(p2)))) @@ -463,6 +462,11 @@ func __ParamEnumRef(p1 *int32, p2 *C.Vector) int32 { return __result } +//export __ParamVariant +func __ParamVariant(p1 *C.Variant, p2 *C.Vector) { + ParamVariant(plugify.GetVariantData((*plugify.PlgVariant)(unsafe.Pointer(p1))), plugify.GetVectorDataVariant((*plugify.PlgVector)(unsafe.Pointer(p2)))) +} + //export __ParamVariantRef func __ParamVariantRef(p1 *C.Variant, p2 *C.Vector) { _p1 := plugify.GetVariantData((*plugify.PlgVariant)(unsafe.Pointer(p1))) @@ -561,6 +565,12 @@ func __CallFuncDouble(func_ unsafe.Pointer) float64 { return __result } +//export __CallFuncFunction +func __CallFuncFunction(func_ unsafe.Pointer) uintptr { + __result := CallFuncFunction(plugify.GetDelegateForFunctionPointer(func_, reflect.TypeOf(FuncFunction(nil))).(FuncFunction)) + return __result +} + //export __CallFuncString func __CallFuncString(func_ unsafe.Pointer) C.String { __result := CallFuncString(plugify.GetDelegateForFunctionPointer(func_, reflect.TypeOf(FuncString(nil))).(FuncString)) @@ -575,12 +585,6 @@ func __CallFuncAny(func_ unsafe.Pointer) C.Variant { return *(*C.Variant)(unsafe.Pointer(&__return)) } -//export __CallFuncFunction -func __CallFuncFunction(func_ unsafe.Pointer) uintptr { - __result := CallFuncFunction(plugify.GetDelegateForFunctionPointer(func_, reflect.TypeOf(FuncFunction(nil))).(FuncFunction)) - return __result -} - //export __CallFuncBoolVector func __CallFuncBoolVector(func_ unsafe.Pointer) C.Vector { __result := CallFuncBoolVector(plugify.GetDelegateForFunctionPointer(func_, reflect.TypeOf(FuncBoolVector(nil))).(FuncBoolVector)) @@ -591,14 +595,14 @@ func __CallFuncBoolVector(func_ unsafe.Pointer) C.Vector { //export __CallFuncChar8Vector func __CallFuncChar8Vector(func_ unsafe.Pointer) C.Vector { __result := CallFuncChar8Vector(plugify.GetDelegateForFunctionPointer(func_, reflect.TypeOf(FuncChar8Vector(nil))).(FuncChar8Vector)) - __return := plugify.ConstructVectorChar8(__result) + __return := plugify.ConstructVectorInt8(__result) return *(*C.Vector)(unsafe.Pointer(&__return)) } //export __CallFuncChar16Vector func __CallFuncChar16Vector(func_ unsafe.Pointer) C.Vector { __result := CallFuncChar16Vector(plugify.GetDelegateForFunctionPointer(func_, reflect.TypeOf(FuncChar16Vector(nil))).(FuncChar16Vector)) - __return := plugify.ConstructVectorChar16(__result) + __return := plugify.ConstructVectorUInt16(__result) return *(*C.Vector)(unsafe.Pointer(&__return)) } @@ -967,6 +971,979 @@ func __CallFuncEnum(func_ unsafe.Pointer) C.String { return *(*C.String)(unsafe.Pointer(&__return)) } +//export __ReverseNoParamReturnVoid +func __ReverseNoParamReturnVoid() C.String { + __result := ReverseNoParamReturnVoid() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnBool +func __ReverseNoParamReturnBool() C.String { + __result := ReverseNoParamReturnBool() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnChar8 +func __ReverseNoParamReturnChar8() C.String { + __result := ReverseNoParamReturnChar8() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnChar16 +func __ReverseNoParamReturnChar16() C.String { + __result := ReverseNoParamReturnChar16() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnInt8 +func __ReverseNoParamReturnInt8() C.String { + __result := ReverseNoParamReturnInt8() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnInt16 +func __ReverseNoParamReturnInt16() C.String { + __result := ReverseNoParamReturnInt16() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnInt32 +func __ReverseNoParamReturnInt32() C.String { + __result := ReverseNoParamReturnInt32() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnInt64 +func __ReverseNoParamReturnInt64() C.String { + __result := ReverseNoParamReturnInt64() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnUInt8 +func __ReverseNoParamReturnUInt8() C.String { + __result := ReverseNoParamReturnUInt8() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnUInt16 +func __ReverseNoParamReturnUInt16() C.String { + __result := ReverseNoParamReturnUInt16() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnUInt32 +func __ReverseNoParamReturnUInt32() C.String { + __result := ReverseNoParamReturnUInt32() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnUInt64 +func __ReverseNoParamReturnUInt64() C.String { + __result := ReverseNoParamReturnUInt64() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnPointer +func __ReverseNoParamReturnPointer() C.String { + __result := ReverseNoParamReturnPointer() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnFloat +func __ReverseNoParamReturnFloat() C.String { + __result := ReverseNoParamReturnFloat() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnDouble +func __ReverseNoParamReturnDouble() C.String { + __result := ReverseNoParamReturnDouble() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnFunction +func __ReverseNoParamReturnFunction() C.String { + __result := ReverseNoParamReturnFunction() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnString +func __ReverseNoParamReturnString() C.String { + __result := ReverseNoParamReturnString() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnAny +func __ReverseNoParamReturnAny() C.String { + __result := ReverseNoParamReturnAny() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnArrayBool +func __ReverseNoParamReturnArrayBool() C.String { + __result := ReverseNoParamReturnArrayBool() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnArrayChar8 +func __ReverseNoParamReturnArrayChar8() C.String { + __result := ReverseNoParamReturnArrayChar8() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnArrayChar16 +func __ReverseNoParamReturnArrayChar16() C.String { + __result := ReverseNoParamReturnArrayChar16() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnArrayInt8 +func __ReverseNoParamReturnArrayInt8() C.String { + __result := ReverseNoParamReturnArrayInt8() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnArrayInt16 +func __ReverseNoParamReturnArrayInt16() C.String { + __result := ReverseNoParamReturnArrayInt16() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnArrayInt32 +func __ReverseNoParamReturnArrayInt32() C.String { + __result := ReverseNoParamReturnArrayInt32() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnArrayInt64 +func __ReverseNoParamReturnArrayInt64() C.String { + __result := ReverseNoParamReturnArrayInt64() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnArrayUInt8 +func __ReverseNoParamReturnArrayUInt8() C.String { + __result := ReverseNoParamReturnArrayUInt8() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnArrayUInt16 +func __ReverseNoParamReturnArrayUInt16() C.String { + __result := ReverseNoParamReturnArrayUInt16() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnArrayUInt32 +func __ReverseNoParamReturnArrayUInt32() C.String { + __result := ReverseNoParamReturnArrayUInt32() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnArrayUInt64 +func __ReverseNoParamReturnArrayUInt64() C.String { + __result := ReverseNoParamReturnArrayUInt64() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnArrayPointer +func __ReverseNoParamReturnArrayPointer() C.String { + __result := ReverseNoParamReturnArrayPointer() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnArrayFloat +func __ReverseNoParamReturnArrayFloat() C.String { + __result := ReverseNoParamReturnArrayFloat() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnArrayDouble +func __ReverseNoParamReturnArrayDouble() C.String { + __result := ReverseNoParamReturnArrayDouble() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnArrayString +func __ReverseNoParamReturnArrayString() C.String { + __result := ReverseNoParamReturnArrayString() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnArrayAny +func __ReverseNoParamReturnArrayAny() C.String { + __result := ReverseNoParamReturnArrayAny() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnVector2 +func __ReverseNoParamReturnVector2() C.String { + __result := ReverseNoParamReturnVector2() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnVector3 +func __ReverseNoParamReturnVector3() C.String { + __result := ReverseNoParamReturnVector3() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnVector4 +func __ReverseNoParamReturnVector4() C.String { + __result := ReverseNoParamReturnVector4() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseNoParamReturnMatrix4x4 +func __ReverseNoParamReturnMatrix4x4() C.String { + __result := ReverseNoParamReturnMatrix4x4() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParam1 +func __ReverseParam1() C.String { + __result := ReverseParam1() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParam2 +func __ReverseParam2() C.String { + __result := ReverseParam2() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParam3 +func __ReverseParam3() C.String { + __result := ReverseParam3() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParam4 +func __ReverseParam4() C.String { + __result := ReverseParam4() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParam5 +func __ReverseParam5() C.String { + __result := ReverseParam5() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParam6 +func __ReverseParam6() C.String { + __result := ReverseParam6() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParam7 +func __ReverseParam7() C.String { + __result := ReverseParam7() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParam8 +func __ReverseParam8() C.String { + __result := ReverseParam8() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParam9 +func __ReverseParam9() C.String { + __result := ReverseParam9() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParam10 +func __ReverseParam10() C.String { + __result := ReverseParam10() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParamRef1 +func __ReverseParamRef1() C.String { + __result := ReverseParamRef1() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParamRef2 +func __ReverseParamRef2() C.String { + __result := ReverseParamRef2() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParamRef3 +func __ReverseParamRef3() C.String { + __result := ReverseParamRef3() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParamRef4 +func __ReverseParamRef4() C.String { + __result := ReverseParamRef4() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParamRef5 +func __ReverseParamRef5() C.String { + __result := ReverseParamRef5() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParamRef6 +func __ReverseParamRef6() C.String { + __result := ReverseParamRef6() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParamRef7 +func __ReverseParamRef7() C.String { + __result := ReverseParamRef7() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParamRef8 +func __ReverseParamRef8() C.String { + __result := ReverseParamRef8() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParamRef9 +func __ReverseParamRef9() C.String { + __result := ReverseParamRef9() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParamRef10 +func __ReverseParamRef10() C.String { + __result := ReverseParamRef10() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParamRefVectors +func __ReverseParamRefVectors() C.String { + __result := ReverseParamRefVectors() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParamAllPrimitives +func __ReverseParamAllPrimitives() C.String { + __result := ReverseParamAllPrimitives() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParamEnum +func __ReverseParamEnum() C.String { + __result := ReverseParamEnum() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParamEnumRef +func __ReverseParamEnumRef() C.String { + __result := ReverseParamEnumRef() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParamVariant +func __ReverseParamVariant() C.String { + __result := ReverseParamVariant() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseParamVariantRef +func __ReverseParamVariantRef() C.String { + __result := ReverseParamVariantRef() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncVoid +func __ReverseCallFuncVoid() C.String { + __result := ReverseCallFuncVoid() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncBool +func __ReverseCallFuncBool() C.String { + __result := ReverseCallFuncBool() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncChar8 +func __ReverseCallFuncChar8() C.String { + __result := ReverseCallFuncChar8() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncChar16 +func __ReverseCallFuncChar16() C.String { + __result := ReverseCallFuncChar16() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncInt8 +func __ReverseCallFuncInt8() C.String { + __result := ReverseCallFuncInt8() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncInt16 +func __ReverseCallFuncInt16() C.String { + __result := ReverseCallFuncInt16() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncInt32 +func __ReverseCallFuncInt32() C.String { + __result := ReverseCallFuncInt32() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncInt64 +func __ReverseCallFuncInt64() C.String { + __result := ReverseCallFuncInt64() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncUInt8 +func __ReverseCallFuncUInt8() C.String { + __result := ReverseCallFuncUInt8() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncUInt16 +func __ReverseCallFuncUInt16() C.String { + __result := ReverseCallFuncUInt16() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncUInt32 +func __ReverseCallFuncUInt32() C.String { + __result := ReverseCallFuncUInt32() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncUInt64 +func __ReverseCallFuncUInt64() C.String { + __result := ReverseCallFuncUInt64() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncPtr +func __ReverseCallFuncPtr() C.String { + __result := ReverseCallFuncPtr() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncFloat +func __ReverseCallFuncFloat() C.String { + __result := ReverseCallFuncFloat() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncDouble +func __ReverseCallFuncDouble() C.String { + __result := ReverseCallFuncDouble() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncString +func __ReverseCallFuncString() C.String { + __result := ReverseCallFuncString() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncAny +func __ReverseCallFuncAny() C.String { + __result := ReverseCallFuncAny() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncBoolVector +func __ReverseCallFuncBoolVector() C.String { + __result := ReverseCallFuncBoolVector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncChar8Vector +func __ReverseCallFuncChar8Vector() C.String { + __result := ReverseCallFuncChar8Vector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncChar16Vector +func __ReverseCallFuncChar16Vector() C.String { + __result := ReverseCallFuncChar16Vector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncInt8Vector +func __ReverseCallFuncInt8Vector() C.String { + __result := ReverseCallFuncInt8Vector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncInt16Vector +func __ReverseCallFuncInt16Vector() C.String { + __result := ReverseCallFuncInt16Vector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncInt32Vector +func __ReverseCallFuncInt32Vector() C.String { + __result := ReverseCallFuncInt32Vector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncInt64Vector +func __ReverseCallFuncInt64Vector() C.String { + __result := ReverseCallFuncInt64Vector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncUInt8Vector +func __ReverseCallFuncUInt8Vector() C.String { + __result := ReverseCallFuncUInt8Vector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncUInt16Vector +func __ReverseCallFuncUInt16Vector() C.String { + __result := ReverseCallFuncUInt16Vector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncUInt32Vector +func __ReverseCallFuncUInt32Vector() C.String { + __result := ReverseCallFuncUInt32Vector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncUInt64Vector +func __ReverseCallFuncUInt64Vector() C.String { + __result := ReverseCallFuncUInt64Vector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncPtrVector +func __ReverseCallFuncPtrVector() C.String { + __result := ReverseCallFuncPtrVector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncFloatVector +func __ReverseCallFuncFloatVector() C.String { + __result := ReverseCallFuncFloatVector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncDoubleVector +func __ReverseCallFuncDoubleVector() C.String { + __result := ReverseCallFuncDoubleVector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncStringVector +func __ReverseCallFuncStringVector() C.String { + __result := ReverseCallFuncStringVector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncAnyVector +func __ReverseCallFuncAnyVector() C.String { + __result := ReverseCallFuncAnyVector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncVec2Vector +func __ReverseCallFuncVec2Vector() C.String { + __result := ReverseCallFuncVec2Vector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncVec3Vector +func __ReverseCallFuncVec3Vector() C.String { + __result := ReverseCallFuncVec3Vector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncVec4Vector +func __ReverseCallFuncVec4Vector() C.String { + __result := ReverseCallFuncVec4Vector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncMat4x4Vector +func __ReverseCallFuncMat4x4Vector() C.String { + __result := ReverseCallFuncMat4x4Vector() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncVec2 +func __ReverseCallFuncVec2() C.String { + __result := ReverseCallFuncVec2() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncVec3 +func __ReverseCallFuncVec3() C.String { + __result := ReverseCallFuncVec3() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncVec4 +func __ReverseCallFuncVec4() C.String { + __result := ReverseCallFuncVec4() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncMat4x4 +func __ReverseCallFuncMat4x4() C.String { + __result := ReverseCallFuncMat4x4() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc1 +func __ReverseCallFunc1() C.String { + __result := ReverseCallFunc1() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc2 +func __ReverseCallFunc2() C.String { + __result := ReverseCallFunc2() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc3 +func __ReverseCallFunc3() C.String { + __result := ReverseCallFunc3() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc4 +func __ReverseCallFunc4() C.String { + __result := ReverseCallFunc4() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc5 +func __ReverseCallFunc5() C.String { + __result := ReverseCallFunc5() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc6 +func __ReverseCallFunc6() C.String { + __result := ReverseCallFunc6() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc7 +func __ReverseCallFunc7() C.String { + __result := ReverseCallFunc7() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc8 +func __ReverseCallFunc8() C.String { + __result := ReverseCallFunc8() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc9 +func __ReverseCallFunc9() C.String { + __result := ReverseCallFunc9() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc10 +func __ReverseCallFunc10() C.String { + __result := ReverseCallFunc10() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc11 +func __ReverseCallFunc11() C.String { + __result := ReverseCallFunc11() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc12 +func __ReverseCallFunc12() C.String { + __result := ReverseCallFunc12() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc13 +func __ReverseCallFunc13() C.String { + __result := ReverseCallFunc13() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc14 +func __ReverseCallFunc14() C.String { + __result := ReverseCallFunc14() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc15 +func __ReverseCallFunc15() C.String { + __result := ReverseCallFunc15() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc16 +func __ReverseCallFunc16() C.String { + __result := ReverseCallFunc16() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc17 +func __ReverseCallFunc17() C.String { + __result := ReverseCallFunc17() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc18 +func __ReverseCallFunc18() C.String { + __result := ReverseCallFunc18() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc19 +func __ReverseCallFunc19() C.String { + __result := ReverseCallFunc19() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc20 +func __ReverseCallFunc20() C.String { + __result := ReverseCallFunc20() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc21 +func __ReverseCallFunc21() C.String { + __result := ReverseCallFunc21() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc22 +func __ReverseCallFunc22() C.String { + __result := ReverseCallFunc22() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc23 +func __ReverseCallFunc23() C.String { + __result := ReverseCallFunc23() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc24 +func __ReverseCallFunc24() C.String { + __result := ReverseCallFunc24() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc25 +func __ReverseCallFunc25() C.String { + __result := ReverseCallFunc25() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc26 +func __ReverseCallFunc26() C.String { + __result := ReverseCallFunc26() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc27 +func __ReverseCallFunc27() C.String { + __result := ReverseCallFunc27() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc28 +func __ReverseCallFunc28() C.String { + __result := ReverseCallFunc28() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc29 +func __ReverseCallFunc29() C.String { + __result := ReverseCallFunc29() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc30 +func __ReverseCallFunc30() C.String { + __result := ReverseCallFunc30() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc31 +func __ReverseCallFunc31() C.String { + __result := ReverseCallFunc31() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc32 +func __ReverseCallFunc32() C.String { + __result := ReverseCallFunc32() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFunc33 +func __ReverseCallFunc33() C.String { + __result := ReverseCallFunc33() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + +//export __ReverseCallFuncEnum +func __ReverseCallFuncEnum() C.String { + __result := ReverseCallFuncEnum() + __return := plugify.ConstructString(__result) + return *(*C.String)(unsafe.Pointer(&__return)) +} + //export __ReverseCall func __ReverseCall(test *C.String) { ReverseCall(plugify.GetStringData((*plugify.PlgString)(unsafe.Pointer(test)))) diff --git a/test/cross_call_worker/autoexports.h b/test/cross_call_worker/autoexports.h index 19410b3..7ca0eab 100644 --- a/test/cross_call_worker/autoexports.h +++ b/test/cross_call_worker/autoexports.h @@ -1,6 +1,5 @@ #pragma once -// autoexports.h -#pragma once +// autoexports.h - Auto-generated by Plugify Go Generator #include #include @@ -19,31 +18,31 @@ typedef struct Vector3 { float x, y, z; } Vector3; typedef struct Vector4 { float x, y, z, w; } Vector4; typedef struct Matrix4x4 { float m[4][4]; } Matrix4x4; typedef struct Variant { - union { - bool boolean; - char char8; - char16_t char16; - int8_t int8; - int16_t int16; - int32_t int32; - int64_t int64; - uint8_t uint8; - uint16_t uint16; - uint32_t uint32; - uint64_t uint64; - void* ptr; - float flt; - double dbl; - String str; - Vector vec; - Vector2 vec2; - Vector3 vec3; - Vector4 vec4; - }; + union { + bool boolean; + char char8; + char16_t char16; + int8_t int8; + int16_t int16; + int32_t int32; + int64_t int64; + uint8_t uint8; + uint16_t uint16; + uint32_t uint32; + uint64_t uint64; + void* ptr; + float flt; + double dbl; + String str; + Vector vec; + Vector2 vec2; + Vector3 vec3; + Vector4 vec4; + }; #if INTPTR_MAX == INT32_MAX volatile char pad[8]; #endif - uint8_t current; + uint8_t current; } Variant; #ifdef __cplusplus diff --git a/test/cross_call_worker/callbacks.go b/test/cross_call_worker/callbacks.go index c70c83a..d847e95 100644 --- a/test/cross_call_worker/callbacks.go +++ b/test/cross_call_worker/callbacks.go @@ -2,9 +2,10 @@ package main import ( "fmt" - "github.com/untrustedmodders/go-plugify" "plugify-plugin/cross_call_master" "unsafe" + + "github.com/untrustedmodders/go-plugify" ) func MockVoid() { @@ -588,6 +589,6 @@ func MockFunc33(variant *any) { } func MockFuncEnum(p1 cross_call_master.Example, p2 *[]cross_call_master.Example) []cross_call_master.Example { - *p2 = []cross_call_master.Example{cross_call_master.First, cross_call_master.Second, cross_call_master.Third} - return []cross_call_master.Example{p1, cross_call_master.Forth} + *p2 = []cross_call_master.Example{cross_call_master.Example_First, cross_call_master.Example_Second, cross_call_master.Example_Third} + return []cross_call_master.Example{p1, cross_call_master.Example_Forth} } diff --git a/test/cross_call_worker/cross_call_master/cross_call_master.go b/test/cross_call_worker/cross_call_master/cross_call_master.go index 9a3e994..73bec8c 100644 --- a/test/cross_call_worker/cross_call_master/cross_call_master.go +++ b/test/cross_call_worker/cross_call_master/cross_call_master.go @@ -147,12 +147,40 @@ package cross_call_master #cgo noescape CallFunc32Callback #cgo noescape CallFunc33Callback #cgo noescape CallFuncEnumCallback +#cgo noescape ResourceHandleCreate +#cgo noescape ResourceHandleCreateDefault +#cgo noescape ResourceHandleDestroy +#cgo noescape ResourceHandleGetId +#cgo noescape ResourceHandleGetName +#cgo noescape ResourceHandleSetName +#cgo noescape ResourceHandleIncrementCounter +#cgo noescape ResourceHandleGetCounter +#cgo noescape ResourceHandleAddData +#cgo noescape ResourceHandleGetData +#cgo noescape ResourceHandleGetAliveCount +#cgo noescape ResourceHandleGetTotalCreated +#cgo noescape ResourceHandleGetTotalDestroyed +#cgo noescape CounterCreate +#cgo noescape CounterCreateZero +#cgo noescape CounterGetValue +#cgo noescape CounterSetValue +#cgo noescape CounterIncrement +#cgo noescape CounterDecrement +#cgo noescape CounterAdd +#cgo noescape CounterReset +#cgo noescape CounterIsPositive +#cgo noescape CounterCompare +#cgo noescape CounterSum */ import "C" import ( - "github.com/untrustedmodders/go-plugify" + "errors" "reflect" + _ "reflect" + "runtime" "unsafe" + + "github.com/untrustedmodders/go-plugify" ) // Generated with https://github.com/untrustedmodders/plugify-module-golang/blob/main/generator/generator.py from cross_call_master @@ -160,92 +188,166 @@ import ( type Example = int32 const ( - First Example = 1 - Second Example = 2 - Third Example = 3 - Forth Example = 4 + Example_First Example = 1 + Example_Second Example = 2 + Example_Third Example = 3 + Example_Forth Example = 4 ) type NoParamReturnFunctionCallbackFunc func() int32 + type FuncVoid func() + type FuncBool func() bool + type FuncChar8 func() int8 + type FuncChar16 func() uint16 + type FuncInt8 func() int8 + type FuncInt16 func() int16 + type FuncInt32 func() int32 + type FuncInt64 func() int64 + type FuncUInt8 func() uint8 + type FuncUInt16 func() uint16 + type FuncUInt32 func() uint32 + type FuncUInt64 func() uint64 + type FuncPtr func() uintptr + type FuncFloat func() float32 + type FuncDouble func() float64 + type FuncString func() string + type FuncAny func() interface{} + type FuncFunction func() uintptr + type FuncBoolVector func() []bool + type FuncChar8Vector func() []int8 + type FuncChar16Vector func() []uint16 + type FuncInt8Vector func() []int8 + type FuncInt16Vector func() []int16 + type FuncInt32Vector func() []int32 + type FuncInt64Vector func() []int64 + type FuncUInt8Vector func() []uint8 + type FuncUInt16Vector func() []uint16 + type FuncUInt32Vector func() []uint32 + type FuncUInt64Vector func() []uint64 + type FuncPtrVector func() []uintptr + type FuncFloatVector func() []float32 + type FuncDoubleVector func() []float64 + type FuncStringVector func() []string + type FuncAnyVector func() []interface{} + type FuncVec2Vector func() []plugify.Vector2 + type FuncVec3Vector func() []plugify.Vector3 + type FuncVec4Vector func() []plugify.Vector4 + type FuncMat4x4Vector func() []plugify.Matrix4x4 + type FuncVec2 func() plugify.Vector2 + type FuncVec3 func() plugify.Vector3 + type FuncVec4 func() plugify.Vector4 + type FuncMat4x4 func() plugify.Matrix4x4 + type Func1 func(a plugify.Vector3) int32 + type Func2 func(a float32, b int64) int8 + type Func3 func(a uintptr, b plugify.Vector4, c string) + type Func4 func(a bool, b int32, c uint16, d plugify.Matrix4x4) plugify.Vector4 + type Func5 func(a int8, b plugify.Vector2, c uintptr, d float64, e []uint64) bool + type Func6 func(a string, b float32, c []float32, d int16, e []uint8, f uintptr) int64 + type Func7 func(vecC []int8, u16 uint16, ch16 uint16, vecU32 []uint32, vec4 plugify.Vector4, b bool, u64 uint64) float64 + type Func8 func(vec3 plugify.Vector3, vecU32 []uint32, i16 int16, b bool, vec4 plugify.Vector4, vecC16 []uint16, ch16 uint16, i32 int32) plugify.Matrix4x4 + type Func9 func(f float32, vec2 plugify.Vector2, vecI8 []int8, u64 uint64, b bool, str string, vec4 plugify.Vector4, i16 int16, ptr uintptr) + type Func10 func(vec4 plugify.Vector4, mat plugify.Matrix4x4, vecU32 []uint32, u64 uint64, vecC []int8, i32 int32, b bool, vec2 plugify.Vector2, i64 int64, d float64) uint32 + type Func11 func(vecB []bool, ch16 uint16, u8 uint8, d float64, vec3 plugify.Vector3, vecI8 []int8, i64 int64, u16 uint16, f float32, vec2 plugify.Vector2, u32 uint32) uintptr + type Func12 func(ptr uintptr, vecD []float64, u32 uint32, d float64, b bool, i32 int32, i8 int8, u64 uint64, f float32, vecPtr []uintptr, i64 int64, ch int8) bool + type Func13 func(i64 int64, vecC []int8, d uint16, f float32, b []bool, vec4 plugify.Vector4, str string, int32_ int32, vec3 plugify.Vector3, ptr uintptr, vec2 plugify.Vector2, arr []uint8, i16 int16) string + type Func14 func(vecC []int8, vecU32 []uint32, mat plugify.Matrix4x4, b bool, ch16 uint16, i32 int32, vecF []float32, u16 uint16, vecU8 []uint8, i8 int8, vec3 plugify.Vector3, vec4 plugify.Vector4, d float64, ptr uintptr) []string + type Func15 func(vecI16 []int16, mat plugify.Matrix4x4, vec4 plugify.Vector4, ptr uintptr, u64 uint64, vecU32 []uint32, b bool, f float32, vecC16 []uint16, u8 uint8, i32 int32, vec2 plugify.Vector2, u16 uint16, d float64, vecU8 []uint8) int16 + type Func16 func(vecB []bool, i16 int16, vecI8 []int8, vec4 plugify.Vector4, mat plugify.Matrix4x4, vec2 plugify.Vector2, vecU64 []uint64, vecC []int8, str string, i64 int64, vecU32 []uint32, vec3 plugify.Vector3, f float32, d float64, i8 int8, u16 uint16) uintptr + type Func17 func(i32 *int32) + type Func18 func(i8 *int8, i16 *int16) plugify.Vector2 + type Func19 func(u32 *uint32, vec3 *plugify.Vector3, vecU32 *[]uint32) + type Func20 func(ch16 *uint16, vec4 *plugify.Vector4, vecU64 *[]uint64, ch *int8) int32 + type Func21 func(mat *plugify.Matrix4x4, vecI32 *[]int32, vec2 *plugify.Vector2, b *bool, extraParam *float64) float32 + type Func22 func(ptr64Ref *uintptr, uint32Ref *uint32, vectorDoubleRef *[]float64, int16Ref *int16, plgStringRef *string, plgVector4Ref *plugify.Vector4) uint64 + type Func23 func(uint64Ref *uint64, plgVector2Ref *plugify.Vector2, vectorInt16Ref *[]int16, char16Ref *uint16, floatRef *float32, int8Ref *int8, vectorUInt8Ref *[]uint8) + type Func24 func(vectorCharRef *[]int8, int64Ref *int64, vectorUInt8Ref *[]uint8, plgVector4Ref *plugify.Vector4, uint64Ref *uint64, vectorptr64Ref *[]uintptr, doubleRef *float64, vectorptr64Ref2 *[]uintptr) plugify.Matrix4x4 + type Func25 func(int32Ref *int32, vectorptr64Ref *[]uintptr, boolRef *bool, uint8Ref *uint8, plgStringRef *string, plgVector3Ref *plugify.Vector3, int64Ref *int64, plgVector4Ref *plugify.Vector4, uint16Ref *uint16) float64 + type Func26 func(char16Ref *uint16, plgVector2Ref *plugify.Vector2, plgMatrix4x4Ref *plugify.Matrix4x4, vectorFloatRef *[]float32, int16Ref *int16, uint64Ref *uint64, uint32Ref *uint32, vectorUInt16Ref *[]uint16, ptr64Ref *uintptr, boolRef *bool) int8 + type Func27 func(floatRef *float32, plgVector3Ref *plugify.Vector3, ptr64Ref *uintptr, plgVector2Ref *plugify.Vector2, vectorInt16Ref *[]int16, plgMatrix4x4Ref *plugify.Matrix4x4, boolRef *bool, plgVector4Ref *plugify.Vector4, int8Ref *int8, int32Ref *int32, vectorUInt8Ref *[]uint8) uint8 + type Func28 func(ptr64Ref *uintptr, uint16Ref *uint16, vectorUInt32Ref *[]uint32, plgMatrix4x4Ref *plugify.Matrix4x4, floatRef *float32, plgVector4Ref *plugify.Vector4, plgStringRef *string, vectorUInt64Ref *[]uint64, int64Ref *int64, boolRef *bool, plgVector3Ref *plugify.Vector3, vectorFloatRef *[]float32) string + type Func29 func(plgVector4Ref *plugify.Vector4, int32Ref *int32, vectorInt8Ref *[]int8, doubleRef *float64, boolRef *bool, int8Ref *int8, vectorUInt16Ref *[]uint16, floatRef *float32, plgStringRef *string, plgMatrix4x4Ref *plugify.Matrix4x4, uint64Ref *uint64, plgVector3Ref *plugify.Vector3, vectorInt64Ref *[]int64) []string + type Func30 func(ptr64Ref *uintptr, plgVector4Ref *plugify.Vector4, int64Ref *int64, vectorUInt32Ref *[]uint32, boolRef *bool, plgStringRef *string, plgVector3Ref *plugify.Vector3, vectorUInt8Ref *[]uint8, floatRef *float32, plgVector2Ref *plugify.Vector2, plgMatrix4x4Ref *plugify.Matrix4x4, int8Ref *int8, vectorFloatRef *[]float32, doubleRef *float64) int32 + type Func31 func(charRef *int8, uint32Ref *uint32, vectorUInt64Ref *[]uint64, plgVector4Ref *plugify.Vector4, plgStringRef *string, boolRef *bool, int64Ref *int64, vec2Ref *plugify.Vector2, int8Ref *int8, uint16Ref *uint16, vectorInt16Ref *[]int16, mat4x4Ref *plugify.Matrix4x4, vec3Ref *plugify.Vector3, floatRef *float32, vectorDoubleRef *[]float64) plugify.Vector3 + type Func32 func(p1 *int32, p2 *uint16, p3 *[]int8, p4 *plugify.Vector4, p5 *uintptr, p6 *[]uint32, p7 *plugify.Matrix4x4, p8 *uint64, p9 *string, p10 *int64, p11 *plugify.Vector2, p12 *[]int8, p13 *bool, p14 *plugify.Vector3, p15 *uint8, p16 *[]uint16) float64 + type Func33 func(variant *interface{}) + type FuncEnum func(p1 Example, p2 *[]Example) []Example -// ReverseReturn - No description provided. -// @param returnString: No description available. func ReverseReturn(returnString string) { __returnString := plugify.ConstructString(returnString) plugify.Block{ @@ -259,118 +361,85 @@ func ReverseReturn(returnString string) { }.Do() } -// NoParamReturnVoidCallback - No description provided. func NoParamReturnVoidCallback() { C.NoParamReturnVoidCallback() } -// NoParamReturnBoolCallback - No description provided. -// @return No description available. func NoParamReturnBoolCallback() bool { __retVal := bool(C.NoParamReturnBoolCallback()) return __retVal } -// NoParamReturnChar8Callback - No description provided. -// @return No description available. func NoParamReturnChar8Callback() int8 { __retVal := int8(C.NoParamReturnChar8Callback()) return __retVal } -// NoParamReturnChar16Callback - No description provided. -// @return No description available. func NoParamReturnChar16Callback() uint16 { __retVal := uint16(C.NoParamReturnChar16Callback()) return __retVal } -// NoParamReturnInt8Callback - No description provided. -// @return No description available. func NoParamReturnInt8Callback() int8 { __retVal := int8(C.NoParamReturnInt8Callback()) return __retVal } -// NoParamReturnInt16Callback - No description provided. -// @return No description available. func NoParamReturnInt16Callback() int16 { __retVal := int16(C.NoParamReturnInt16Callback()) return __retVal } -// NoParamReturnInt32Callback - No description provided. -// @return No description available. func NoParamReturnInt32Callback() int32 { __retVal := int32(C.NoParamReturnInt32Callback()) return __retVal } -// NoParamReturnInt64Callback - No description provided. -// @return No description available. func NoParamReturnInt64Callback() int64 { __retVal := int64(C.NoParamReturnInt64Callback()) return __retVal } -// NoParamReturnUInt8Callback - No description provided. -// @return No description available. func NoParamReturnUInt8Callback() uint8 { __retVal := uint8(C.NoParamReturnUInt8Callback()) return __retVal } -// NoParamReturnUInt16Callback - No description provided. -// @return No description available. func NoParamReturnUInt16Callback() uint16 { __retVal := uint16(C.NoParamReturnUInt16Callback()) return __retVal } -// NoParamReturnUInt32Callback - No description provided. -// @return No description available. func NoParamReturnUInt32Callback() uint32 { __retVal := uint32(C.NoParamReturnUInt32Callback()) return __retVal } -// NoParamReturnUInt64Callback - No description provided. -// @return No description available. func NoParamReturnUInt64Callback() uint64 { __retVal := uint64(C.NoParamReturnUInt64Callback()) return __retVal } -// NoParamReturnPointerCallback - No description provided. -// @return No description available. func NoParamReturnPointerCallback() uintptr { __retVal := uintptr(C.NoParamReturnPointerCallback()) return __retVal } -// NoParamReturnFloatCallback - No description provided. -// @return No description available. func NoParamReturnFloatCallback() float32 { __retVal := float32(C.NoParamReturnFloatCallback()) return __retVal } -// NoParamReturnDoubleCallback - No description provided. -// @return No description available. func NoParamReturnDoubleCallback() float64 { __retVal := float64(C.NoParamReturnDoubleCallback()) return __retVal } -// NoParamReturnFunctionCallback - No description provided. -// @return No description available. func NoParamReturnFunctionCallback() NoParamReturnFunctionCallbackFunc { __retVal := plugify.GetDelegateForFunctionPointer(C.NoParamReturnFunctionCallback(), reflect.TypeOf(NoParamReturnFunctionCallbackFunc(nil))).(NoParamReturnFunctionCallbackFunc) return __retVal } -// NoParamReturnStringCallback - No description provided. -// @return No description available. func NoParamReturnStringCallback() string { var __retVal string var __retVal_native plugify.PlgString @@ -389,8 +458,6 @@ func NoParamReturnStringCallback() string { return __retVal } -// NoParamReturnAnyCallback - No description provided. -// @return No description available. func NoParamReturnAnyCallback() interface{} { var __retVal interface{} var __retVal_native plugify.PlgVariant @@ -409,8 +476,6 @@ func NoParamReturnAnyCallback() interface{} { return __retVal } -// NoParamReturnArrayBoolCallback - No description provided. -// @return No description available. func NoParamReturnArrayBoolCallback() []bool { var __retVal []bool var __retVal_native plugify.PlgVector @@ -429,8 +494,6 @@ func NoParamReturnArrayBoolCallback() []bool { return __retVal } -// NoParamReturnArrayChar8Callback - No description provided. -// @return No description available. func NoParamReturnArrayChar8Callback() []int8 { var __retVal []int8 var __retVal_native plugify.PlgVector @@ -449,8 +512,6 @@ func NoParamReturnArrayChar8Callback() []int8 { return __retVal } -// NoParamReturnArrayChar16Callback - No description provided. -// @return No description available. func NoParamReturnArrayChar16Callback() []uint16 { var __retVal []uint16 var __retVal_native plugify.PlgVector @@ -469,8 +530,6 @@ func NoParamReturnArrayChar16Callback() []uint16 { return __retVal } -// NoParamReturnArrayInt8Callback - No description provided. -// @return No description available. func NoParamReturnArrayInt8Callback() []int8 { var __retVal []int8 var __retVal_native plugify.PlgVector @@ -489,8 +548,6 @@ func NoParamReturnArrayInt8Callback() []int8 { return __retVal } -// NoParamReturnArrayInt16Callback - No description provided. -// @return No description available. func NoParamReturnArrayInt16Callback() []int16 { var __retVal []int16 var __retVal_native plugify.PlgVector @@ -509,8 +566,6 @@ func NoParamReturnArrayInt16Callback() []int16 { return __retVal } -// NoParamReturnArrayInt32Callback - No description provided. -// @return No description available. func NoParamReturnArrayInt32Callback() []int32 { var __retVal []int32 var __retVal_native plugify.PlgVector @@ -529,8 +584,6 @@ func NoParamReturnArrayInt32Callback() []int32 { return __retVal } -// NoParamReturnArrayInt64Callback - No description provided. -// @return No description available. func NoParamReturnArrayInt64Callback() []int64 { var __retVal []int64 var __retVal_native plugify.PlgVector @@ -549,8 +602,6 @@ func NoParamReturnArrayInt64Callback() []int64 { return __retVal } -// NoParamReturnArrayUInt8Callback - No description provided. -// @return No description available. func NoParamReturnArrayUInt8Callback() []uint8 { var __retVal []uint8 var __retVal_native plugify.PlgVector @@ -569,8 +620,6 @@ func NoParamReturnArrayUInt8Callback() []uint8 { return __retVal } -// NoParamReturnArrayUInt16Callback - No description provided. -// @return No description available. func NoParamReturnArrayUInt16Callback() []uint16 { var __retVal []uint16 var __retVal_native plugify.PlgVector @@ -589,8 +638,6 @@ func NoParamReturnArrayUInt16Callback() []uint16 { return __retVal } -// NoParamReturnArrayUInt32Callback - No description provided. -// @return No description available. func NoParamReturnArrayUInt32Callback() []uint32 { var __retVal []uint32 var __retVal_native plugify.PlgVector @@ -609,8 +656,6 @@ func NoParamReturnArrayUInt32Callback() []uint32 { return __retVal } -// NoParamReturnArrayUInt64Callback - No description provided. -// @return No description available. func NoParamReturnArrayUInt64Callback() []uint64 { var __retVal []uint64 var __retVal_native plugify.PlgVector @@ -629,8 +674,6 @@ func NoParamReturnArrayUInt64Callback() []uint64 { return __retVal } -// NoParamReturnArrayPointerCallback - No description provided. -// @return No description available. func NoParamReturnArrayPointerCallback() []uintptr { var __retVal []uintptr var __retVal_native plugify.PlgVector @@ -649,8 +692,6 @@ func NoParamReturnArrayPointerCallback() []uintptr { return __retVal } -// NoParamReturnArrayFloatCallback - No description provided. -// @return No description available. func NoParamReturnArrayFloatCallback() []float32 { var __retVal []float32 var __retVal_native plugify.PlgVector @@ -669,8 +710,6 @@ func NoParamReturnArrayFloatCallback() []float32 { return __retVal } -// NoParamReturnArrayDoubleCallback - No description provided. -// @return No description available. func NoParamReturnArrayDoubleCallback() []float64 { var __retVal []float64 var __retVal_native plugify.PlgVector @@ -689,8 +728,6 @@ func NoParamReturnArrayDoubleCallback() []float64 { return __retVal } -// NoParamReturnArrayStringCallback - No description provided. -// @return No description available. func NoParamReturnArrayStringCallback() []string { var __retVal []string var __retVal_native plugify.PlgVector @@ -709,8 +746,6 @@ func NoParamReturnArrayStringCallback() []string { return __retVal } -// NoParamReturnArrayAnyCallback - No description provided. -// @return No description available. func NoParamReturnArrayAnyCallback() []interface{} { var __retVal []interface{} var __retVal_native plugify.PlgVector @@ -729,8 +764,6 @@ func NoParamReturnArrayAnyCallback() []interface{} { return __retVal } -// NoParamReturnArrayVector2Callback - No description provided. -// @return No description available. func NoParamReturnArrayVector2Callback() []plugify.Vector2 { var __retVal []plugify.Vector2 var __retVal_native plugify.PlgVector @@ -749,8 +782,6 @@ func NoParamReturnArrayVector2Callback() []plugify.Vector2 { return __retVal } -// NoParamReturnArrayVector3Callback - No description provided. -// @return No description available. func NoParamReturnArrayVector3Callback() []plugify.Vector3 { var __retVal []plugify.Vector3 var __retVal_native plugify.PlgVector @@ -769,8 +800,6 @@ func NoParamReturnArrayVector3Callback() []plugify.Vector3 { return __retVal } -// NoParamReturnArrayVector4Callback - No description provided. -// @return No description available. func NoParamReturnArrayVector4Callback() []plugify.Vector4 { var __retVal []plugify.Vector4 var __retVal_native plugify.PlgVector @@ -789,8 +818,6 @@ func NoParamReturnArrayVector4Callback() []plugify.Vector4 { return __retVal } -// NoParamReturnArrayMatrix4x4Callback - No description provided. -// @return No description available. func NoParamReturnArrayMatrix4x4Callback() []plugify.Matrix4x4 { var __retVal []plugify.Matrix4x4 var __retVal_native plugify.PlgVector @@ -809,58 +836,41 @@ func NoParamReturnArrayMatrix4x4Callback() []plugify.Matrix4x4 { return __retVal } -// NoParamReturnVector2Callback - No description provided. -// @return No description available. func NoParamReturnVector2Callback() plugify.Vector2 { __native := C.NoParamReturnVector2Callback() __retVal := *(*plugify.Vector2)(unsafe.Pointer(&__native)) return __retVal } -// NoParamReturnVector3Callback - No description provided. -// @return No description available. func NoParamReturnVector3Callback() plugify.Vector3 { __native := C.NoParamReturnVector3Callback() __retVal := *(*plugify.Vector3)(unsafe.Pointer(&__native)) return __retVal } -// NoParamReturnVector4Callback - No description provided. -// @return No description available. func NoParamReturnVector4Callback() plugify.Vector4 { __native := C.NoParamReturnVector4Callback() __retVal := *(*plugify.Vector4)(unsafe.Pointer(&__native)) return __retVal } -// NoParamReturnMatrix4x4Callback - No description provided. -// @return No description available. func NoParamReturnMatrix4x4Callback() plugify.Matrix4x4 { __native := C.NoParamReturnMatrix4x4Callback() __retVal := *(*plugify.Matrix4x4)(unsafe.Pointer(&__native)) return __retVal } -// Param1Callback - No description provided. -// @param a: No description available. func Param1Callback(a int32) { __a := C.int32_t(a) C.Param1Callback(__a) } -// Param2Callback - No description provided. -// @param a: No description available. -// @param b: No description available. func Param2Callback(a int32, b float32) { __a := C.int32_t(a) __b := C.float(b) C.Param2Callback(__a, __b) } -// Param3Callback - No description provided. -// @param a: No description available. -// @param b: No description available. -// @param c: No description available. func Param3Callback(a int32, b float32, c float64) { __a := C.int32_t(a) __b := C.float(b) @@ -868,11 +878,6 @@ func Param3Callback(a int32, b float32, c float64) { C.Param3Callback(__a, __b, __c) } -// Param4Callback - No description provided. -// @param a: No description available. -// @param b: No description available. -// @param c: No description available. -// @param d: No description available. func Param4Callback(a int32, b float32, c float64, d plugify.Vector4) { __a := C.int32_t(a) __b := C.float(b) @@ -881,12 +886,6 @@ func Param4Callback(a int32, b float32, c float64, d plugify.Vector4) { C.Param4Callback(__a, __b, __c, &__d) } -// Param5Callback - No description provided. -// @param a: No description available. -// @param b: No description available. -// @param c: No description available. -// @param d: No description available. -// @param e: No description available. func Param5Callback(a int32, b float32, c float64, d plugify.Vector4, e []int64) { __a := C.int32_t(a) __b := C.float(b) @@ -904,13 +903,6 @@ func Param5Callback(a int32, b float32, c float64, d plugify.Vector4, e []int64) }.Do() } -// Param6Callback - No description provided. -// @param a: No description available. -// @param b: No description available. -// @param c: No description available. -// @param d: No description available. -// @param e: No description available. -// @param f: No description available. func Param6Callback(a int32, b float32, c float64, d plugify.Vector4, e []int64, f int8) { __a := C.int32_t(a) __b := C.float(b) @@ -929,14 +921,6 @@ func Param6Callback(a int32, b float32, c float64, d plugify.Vector4, e []int64, }.Do() } -// Param7Callback - No description provided. -// @param a: No description available. -// @param b: No description available. -// @param c: No description available. -// @param d: No description available. -// @param e: No description available. -// @param f: No description available. -// @param g: No description available. func Param7Callback(a int32, b float32, c float64, d plugify.Vector4, e []int64, f int8, g string) { __a := C.int32_t(a) __b := C.float(b) @@ -957,15 +941,6 @@ func Param7Callback(a int32, b float32, c float64, d plugify.Vector4, e []int64, }.Do() } -// Param8Callback - No description provided. -// @param a: No description available. -// @param b: No description available. -// @param c: No description available. -// @param d: No description available. -// @param e: No description available. -// @param f: No description available. -// @param g: No description available. -// @param h: No description available. func Param8Callback(a int32, b float32, c float64, d plugify.Vector4, e []int64, f int8, g string, h uint16) { __a := C.int32_t(a) __b := C.float(b) @@ -987,16 +962,6 @@ func Param8Callback(a int32, b float32, c float64, d plugify.Vector4, e []int64, }.Do() } -// Param9Callback - No description provided. -// @param a: No description available. -// @param b: No description available. -// @param c: No description available. -// @param d: No description available. -// @param e: No description available. -// @param f: No description available. -// @param g: No description available. -// @param h: No description available. -// @param k: No description available. func Param9Callback(a int32, b float32, c float64, d plugify.Vector4, e []int64, f int8, g string, h uint16, k int16) { __a := C.int32_t(a) __b := C.float(b) @@ -1019,17 +984,6 @@ func Param9Callback(a int32, b float32, c float64, d plugify.Vector4, e []int64, }.Do() } -// Param10Callback - No description provided. -// @param a: No description available. -// @param b: No description available. -// @param c: No description available. -// @param d: No description available. -// @param e: No description available. -// @param f: No description available. -// @param g: No description available. -// @param h: No description available. -// @param k: No description available. -// @param l: No description available. func Param10Callback(a int32, b float32, c float64, d plugify.Vector4, e []int64, f int8, g string, h uint16, k int16, l uintptr) { __a := C.int32_t(a) __b := C.float(b) @@ -1053,8 +1007,6 @@ func Param10Callback(a int32, b float32, c float64, d plugify.Vector4, e []int64 }.Do() } -// ParamRef1Callback - No description provided. -// @param a: No description available. func ParamRef1Callback(a *int32) { __a := C.int32_t(*a) C.ParamRef1Callback(&__a) @@ -1062,9 +1014,6 @@ func ParamRef1Callback(a *int32) { *a = int32(__a) } -// ParamRef2Callback - No description provided. -// @param a: No description available. -// @param b: No description available. func ParamRef2Callback(a *int32, b *float32) { __a := C.int32_t(*a) __b := C.float(*b) @@ -1074,10 +1023,6 @@ func ParamRef2Callback(a *int32, b *float32) { *b = float32(__b) } -// ParamRef3Callback - No description provided. -// @param a: No description available. -// @param b: No description available. -// @param c: No description available. func ParamRef3Callback(a *int32, b *float32, c *float64) { __a := C.int32_t(*a) __b := C.float(*b) @@ -1089,11 +1034,6 @@ func ParamRef3Callback(a *int32, b *float32, c *float64) { *c = float64(__c) } -// ParamRef4Callback - No description provided. -// @param a: No description available. -// @param b: No description available. -// @param c: No description available. -// @param d: No description available. func ParamRef4Callback(a *int32, b *float32, c *float64, d *plugify.Vector4) { __a := C.int32_t(*a) __b := C.float(*b) @@ -1107,12 +1047,6 @@ func ParamRef4Callback(a *int32, b *float32, c *float64, d *plugify.Vector4) { *d = *(*plugify.Vector4)(unsafe.Pointer(&__d)) } -// ParamRef5Callback - No description provided. -// @param a: No description available. -// @param b: No description available. -// @param c: No description available. -// @param d: No description available. -// @param e: No description available. func ParamRef5Callback(a *int32, b *float32, c *float64, d *plugify.Vector4, e *[]int64) { __a := C.int32_t(*a) __b := C.float(*b) @@ -1136,13 +1070,6 @@ func ParamRef5Callback(a *int32, b *float32, c *float64, d *plugify.Vector4, e * }.Do() } -// ParamRef6Callback - No description provided. -// @param a: No description available. -// @param b: No description available. -// @param c: No description available. -// @param d: No description available. -// @param e: No description available. -// @param f: No description available. func ParamRef6Callback(a *int32, b *float32, c *float64, d *plugify.Vector4, e *[]int64, f *int8) { __a := C.int32_t(*a) __b := C.float(*b) @@ -1168,14 +1095,6 @@ func ParamRef6Callback(a *int32, b *float32, c *float64, d *plugify.Vector4, e * }.Do() } -// ParamRef7Callback - No description provided. -// @param a: No description available. -// @param b: No description available. -// @param c: No description available. -// @param d: No description available. -// @param e: No description available. -// @param f: No description available. -// @param g: No description available. func ParamRef7Callback(a *int32, b *float32, c *float64, d *plugify.Vector4, e *[]int64, f *int8, g *string) { __a := C.int32_t(*a) __b := C.float(*b) @@ -1204,15 +1123,6 @@ func ParamRef7Callback(a *int32, b *float32, c *float64, d *plugify.Vector4, e * }.Do() } -// ParamRef8Callback - No description provided. -// @param a: No description available. -// @param b: No description available. -// @param c: No description available. -// @param d: No description available. -// @param e: No description available. -// @param f: No description available. -// @param g: No description available. -// @param h: No description available. func ParamRef8Callback(a *int32, b *float32, c *float64, d *plugify.Vector4, e *[]int64, f *int8, g *string, h *uint16) { __a := C.int32_t(*a) __b := C.float(*b) @@ -1243,16 +1153,6 @@ func ParamRef8Callback(a *int32, b *float32, c *float64, d *plugify.Vector4, e * }.Do() } -// ParamRef9Callback - No description provided. -// @param a: No description available. -// @param b: No description available. -// @param c: No description available. -// @param d: No description available. -// @param e: No description available. -// @param f: No description available. -// @param g: No description available. -// @param h: No description available. -// @param k: No description available. func ParamRef9Callback(a *int32, b *float32, c *float64, d *plugify.Vector4, e *[]int64, f *int8, g *string, h *uint16, k *int16) { __a := C.int32_t(*a) __b := C.float(*b) @@ -1285,17 +1185,6 @@ func ParamRef9Callback(a *int32, b *float32, c *float64, d *plugify.Vector4, e * }.Do() } -// ParamRef10Callback - No description provided. -// @param a: No description available. -// @param b: No description available. -// @param c: No description available. -// @param d: No description available. -// @param e: No description available. -// @param f: No description available. -// @param g: No description available. -// @param h: No description available. -// @param k: No description available. -// @param l: No description available. func ParamRef10Callback(a *int32, b *float32, c *float64, d *plugify.Vector4, e *[]int64, f *int8, g *string, h *uint16, k *int16, l *uintptr) { __a := C.int32_t(*a) __b := C.float(*b) @@ -1330,22 +1219,6 @@ func ParamRef10Callback(a *int32, b *float32, c *float64, d *plugify.Vector4, e }.Do() } -// ParamRefVectorsCallback - No description provided. -// @param p1: No description available. -// @param p2: No description available. -// @param p3: No description available. -// @param p4: No description available. -// @param p5: No description available. -// @param p6: No description available. -// @param p7: No description available. -// @param p8: No description available. -// @param p9: No description available. -// @param p10: No description available. -// @param p11: No description available. -// @param p12: No description available. -// @param p13: No description available. -// @param p14: No description available. -// @param p15: No description available. func ParamRefVectorsCallback(p1 *[]bool, p2 *[]int8, p3 *[]uint16, p4 *[]int8, p5 *[]int16, p6 *[]int32, p7 *[]int64, p8 *[]uint8, p9 *[]uint16, p10 *[]uint32, p11 *[]uint64, p12 *[]uintptr, p13 *[]float32, p14 *[]float64, p15 *[]string) { __p1 := plugify.ConstructVectorBool(*p1) __p2 := plugify.ConstructVectorChar8(*p2) @@ -1403,22 +1276,6 @@ func ParamRefVectorsCallback(p1 *[]bool, p2 *[]int8, p3 *[]uint16, p4 *[]int8, p }.Do() } -// ParamAllPrimitivesCallback - No description provided. -// @param p1: No description available. -// @param p2: No description available. -// @param p3: No description available. -// @param p4: No description available. -// @param p5: No description available. -// @param p6: No description available. -// @param p7: No description available. -// @param p8: No description available. -// @param p9: No description available. -// @param p10: No description available. -// @param p11: No description available. -// @param p12: No description available. -// @param p13: No description available. -// @param p14: No description available. -// @return No description available. func ParamAllPrimitivesCallback(p1 bool, p2 int8, p3 uint16, p4 int8, p5 int16, p6 int32, p7 int64, p8 uint8, p9 uint16, p10 uint32, p11 uint64, p12 uintptr, p13 float32, p14 float64) int64 { var __retVal int64 __p1 := C.bool(p1) @@ -1439,10 +1296,6 @@ func ParamAllPrimitivesCallback(p1 bool, p2 int8, p3 uint16, p4 int8, p5 int16, return __retVal } -// ParamEnumCallback - No description provided. -// @param p1: No description available. -// @param p2: No description available. -// @return No description available. func ParamEnumCallback(p1 Example, p2 []Example) int32 { var __retVal int32 __p1 := C.int32_t(p1) @@ -1459,10 +1312,6 @@ func ParamEnumCallback(p1 Example, p2 []Example) int32 { return __retVal } -// ParamEnumRefCallback - No description provided. -// @param p1: No description available. -// @param p2: No description available. -// @return No description available. func ParamEnumRefCallback(p1 *Example, p2 *[]Example) int32 { var __retVal int32 __p1 := C.int32_t(*p1) @@ -1482,9 +1331,6 @@ func ParamEnumRefCallback(p1 *Example, p2 *[]Example) int32 { return __retVal } -// ParamVariantCallback - No description provided. -// @param p1: No description available. -// @param p2: No description available. func ParamVariantCallback(p1 interface{}, p2 []interface{}) { __p1 := plugify.ConstructVariant(p1) __p2 := plugify.ConstructVectorVariant(p2) @@ -1500,9 +1346,6 @@ func ParamVariantCallback(p1 interface{}, p2 []interface{}) { }.Do() } -// ParamVariantRefCallback - No description provided. -// @param p1: No description available. -// @param p2: No description available. func ParamVariantRefCallback(p1 *interface{}, p2 *[]interface{}) { __p1 := plugify.ConstructVariant(*p1) __p2 := plugify.ConstructVectorVariant(*p2) @@ -1521,16 +1364,11 @@ func ParamVariantRefCallback(p1 *interface{}, p2 *[]interface{}) { }.Do() } -// CallFuncVoidCallback - No description provided. -// @param func: No description available. func CallFuncVoidCallback(func_ FuncVoid) { __func_ := plugify.GetFunctionPointerForDelegate(func_) C.CallFuncVoidCallback(__func_) } -// CallFuncBoolCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncBoolCallback(func_ FuncBool) bool { var __retVal bool __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -1538,9 +1376,6 @@ func CallFuncBoolCallback(func_ FuncBool) bool { return __retVal } -// CallFuncChar8Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncChar8Callback(func_ FuncChar8) int8 { var __retVal int8 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -1548,9 +1383,6 @@ func CallFuncChar8Callback(func_ FuncChar8) int8 { return __retVal } -// CallFuncChar16Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncChar16Callback(func_ FuncChar16) uint16 { var __retVal uint16 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -1558,9 +1390,6 @@ func CallFuncChar16Callback(func_ FuncChar16) uint16 { return __retVal } -// CallFuncInt8Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncInt8Callback(func_ FuncInt8) int8 { var __retVal int8 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -1568,9 +1397,6 @@ func CallFuncInt8Callback(func_ FuncInt8) int8 { return __retVal } -// CallFuncInt16Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncInt16Callback(func_ FuncInt16) int16 { var __retVal int16 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -1578,9 +1404,6 @@ func CallFuncInt16Callback(func_ FuncInt16) int16 { return __retVal } -// CallFuncInt32Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncInt32Callback(func_ FuncInt32) int32 { var __retVal int32 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -1588,9 +1411,6 @@ func CallFuncInt32Callback(func_ FuncInt32) int32 { return __retVal } -// CallFuncInt64Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncInt64Callback(func_ FuncInt64) int64 { var __retVal int64 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -1598,9 +1418,6 @@ func CallFuncInt64Callback(func_ FuncInt64) int64 { return __retVal } -// CallFuncUInt8Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncUInt8Callback(func_ FuncUInt8) uint8 { var __retVal uint8 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -1608,9 +1425,6 @@ func CallFuncUInt8Callback(func_ FuncUInt8) uint8 { return __retVal } -// CallFuncUInt16Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncUInt16Callback(func_ FuncUInt16) uint16 { var __retVal uint16 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -1618,9 +1432,6 @@ func CallFuncUInt16Callback(func_ FuncUInt16) uint16 { return __retVal } -// CallFuncUInt32Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncUInt32Callback(func_ FuncUInt32) uint32 { var __retVal uint32 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -1628,9 +1439,6 @@ func CallFuncUInt32Callback(func_ FuncUInt32) uint32 { return __retVal } -// CallFuncUInt64Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncUInt64Callback(func_ FuncUInt64) uint64 { var __retVal uint64 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -1638,9 +1446,6 @@ func CallFuncUInt64Callback(func_ FuncUInt64) uint64 { return __retVal } -// CallFuncPtrCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncPtrCallback(func_ FuncPtr) uintptr { var __retVal uintptr __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -1648,9 +1453,6 @@ func CallFuncPtrCallback(func_ FuncPtr) uintptr { return __retVal } -// CallFuncFloatCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncFloatCallback(func_ FuncFloat) float32 { var __retVal float32 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -1658,9 +1460,6 @@ func CallFuncFloatCallback(func_ FuncFloat) float32 { return __retVal } -// CallFuncDoubleCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncDoubleCallback(func_ FuncDouble) float64 { var __retVal float64 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -1668,9 +1467,6 @@ func CallFuncDoubleCallback(func_ FuncDouble) float64 { return __retVal } -// CallFuncStringCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncStringCallback(func_ FuncString) string { var __retVal string var __retVal_native plugify.PlgString @@ -1690,9 +1486,6 @@ func CallFuncStringCallback(func_ FuncString) string { return __retVal } -// CallFuncAnyCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncAnyCallback(func_ FuncAny) interface{} { var __retVal interface{} var __retVal_native plugify.PlgVariant @@ -1712,9 +1505,6 @@ func CallFuncAnyCallback(func_ FuncAny) interface{} { return __retVal } -// CallFuncFunctionCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncFunctionCallback(func_ FuncFunction) uintptr { var __retVal uintptr __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -1722,9 +1512,6 @@ func CallFuncFunctionCallback(func_ FuncFunction) uintptr { return __retVal } -// CallFuncBoolVectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncBoolVectorCallback(func_ FuncBoolVector) []bool { var __retVal []bool var __retVal_native plugify.PlgVector @@ -1744,9 +1531,6 @@ func CallFuncBoolVectorCallback(func_ FuncBoolVector) []bool { return __retVal } -// CallFuncChar8VectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncChar8VectorCallback(func_ FuncChar8Vector) []int8 { var __retVal []int8 var __retVal_native plugify.PlgVector @@ -1766,9 +1550,6 @@ func CallFuncChar8VectorCallback(func_ FuncChar8Vector) []int8 { return __retVal } -// CallFuncChar16VectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncChar16VectorCallback(func_ FuncChar16Vector) []uint16 { var __retVal []uint16 var __retVal_native plugify.PlgVector @@ -1788,9 +1569,6 @@ func CallFuncChar16VectorCallback(func_ FuncChar16Vector) []uint16 { return __retVal } -// CallFuncInt8VectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncInt8VectorCallback(func_ FuncInt8Vector) []int8 { var __retVal []int8 var __retVal_native plugify.PlgVector @@ -1810,9 +1588,6 @@ func CallFuncInt8VectorCallback(func_ FuncInt8Vector) []int8 { return __retVal } -// CallFuncInt16VectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncInt16VectorCallback(func_ FuncInt16Vector) []int16 { var __retVal []int16 var __retVal_native plugify.PlgVector @@ -1832,9 +1607,6 @@ func CallFuncInt16VectorCallback(func_ FuncInt16Vector) []int16 { return __retVal } -// CallFuncInt32VectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncInt32VectorCallback(func_ FuncInt32Vector) []int32 { var __retVal []int32 var __retVal_native plugify.PlgVector @@ -1854,9 +1626,6 @@ func CallFuncInt32VectorCallback(func_ FuncInt32Vector) []int32 { return __retVal } -// CallFuncInt64VectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncInt64VectorCallback(func_ FuncInt64Vector) []int64 { var __retVal []int64 var __retVal_native plugify.PlgVector @@ -1876,9 +1645,6 @@ func CallFuncInt64VectorCallback(func_ FuncInt64Vector) []int64 { return __retVal } -// CallFuncUInt8VectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncUInt8VectorCallback(func_ FuncUInt8Vector) []uint8 { var __retVal []uint8 var __retVal_native plugify.PlgVector @@ -1898,9 +1664,6 @@ func CallFuncUInt8VectorCallback(func_ FuncUInt8Vector) []uint8 { return __retVal } -// CallFuncUInt16VectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncUInt16VectorCallback(func_ FuncUInt16Vector) []uint16 { var __retVal []uint16 var __retVal_native plugify.PlgVector @@ -1920,9 +1683,6 @@ func CallFuncUInt16VectorCallback(func_ FuncUInt16Vector) []uint16 { return __retVal } -// CallFuncUInt32VectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncUInt32VectorCallback(func_ FuncUInt32Vector) []uint32 { var __retVal []uint32 var __retVal_native plugify.PlgVector @@ -1942,9 +1702,6 @@ func CallFuncUInt32VectorCallback(func_ FuncUInt32Vector) []uint32 { return __retVal } -// CallFuncUInt64VectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncUInt64VectorCallback(func_ FuncUInt64Vector) []uint64 { var __retVal []uint64 var __retVal_native plugify.PlgVector @@ -1964,9 +1721,6 @@ func CallFuncUInt64VectorCallback(func_ FuncUInt64Vector) []uint64 { return __retVal } -// CallFuncPtrVectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncPtrVectorCallback(func_ FuncPtrVector) []uintptr { var __retVal []uintptr var __retVal_native plugify.PlgVector @@ -1986,9 +1740,6 @@ func CallFuncPtrVectorCallback(func_ FuncPtrVector) []uintptr { return __retVal } -// CallFuncFloatVectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncFloatVectorCallback(func_ FuncFloatVector) []float32 { var __retVal []float32 var __retVal_native plugify.PlgVector @@ -2008,9 +1759,6 @@ func CallFuncFloatVectorCallback(func_ FuncFloatVector) []float32 { return __retVal } -// CallFuncDoubleVectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncDoubleVectorCallback(func_ FuncDoubleVector) []float64 { var __retVal []float64 var __retVal_native plugify.PlgVector @@ -2030,9 +1778,6 @@ func CallFuncDoubleVectorCallback(func_ FuncDoubleVector) []float64 { return __retVal } -// CallFuncStringVectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncStringVectorCallback(func_ FuncStringVector) []string { var __retVal []string var __retVal_native plugify.PlgVector @@ -2052,9 +1797,6 @@ func CallFuncStringVectorCallback(func_ FuncStringVector) []string { return __retVal } -// CallFuncAnyVectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncAnyVectorCallback(func_ FuncAnyVector) []interface{} { var __retVal []interface{} var __retVal_native plugify.PlgVector @@ -2074,9 +1816,6 @@ func CallFuncAnyVectorCallback(func_ FuncAnyVector) []interface{} { return __retVal } -// CallFuncVec2VectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncVec2VectorCallback(func_ FuncVec2Vector) []plugify.Vector2 { var __retVal []plugify.Vector2 var __retVal_native plugify.PlgVector @@ -2096,9 +1835,6 @@ func CallFuncVec2VectorCallback(func_ FuncVec2Vector) []plugify.Vector2 { return __retVal } -// CallFuncVec3VectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncVec3VectorCallback(func_ FuncVec3Vector) []plugify.Vector3 { var __retVal []plugify.Vector3 var __retVal_native plugify.PlgVector @@ -2118,9 +1854,6 @@ func CallFuncVec3VectorCallback(func_ FuncVec3Vector) []plugify.Vector3 { return __retVal } -// CallFuncVec4VectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncVec4VectorCallback(func_ FuncVec4Vector) []plugify.Vector4 { var __retVal []plugify.Vector4 var __retVal_native plugify.PlgVector @@ -2140,9 +1873,6 @@ func CallFuncVec4VectorCallback(func_ FuncVec4Vector) []plugify.Vector4 { return __retVal } -// CallFuncMat4x4VectorCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncMat4x4VectorCallback(func_ FuncMat4x4Vector) []plugify.Matrix4x4 { var __retVal []plugify.Matrix4x4 var __retVal_native plugify.PlgVector @@ -2162,9 +1892,6 @@ func CallFuncMat4x4VectorCallback(func_ FuncMat4x4Vector) []plugify.Matrix4x4 { return __retVal } -// CallFuncVec2Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncVec2Callback(func_ FuncVec2) plugify.Vector2 { var __retVal plugify.Vector2 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -2173,9 +1900,6 @@ func CallFuncVec2Callback(func_ FuncVec2) plugify.Vector2 { return __retVal } -// CallFuncVec3Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncVec3Callback(func_ FuncVec3) plugify.Vector3 { var __retVal plugify.Vector3 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -2184,9 +1908,6 @@ func CallFuncVec3Callback(func_ FuncVec3) plugify.Vector3 { return __retVal } -// CallFuncVec4Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncVec4Callback(func_ FuncVec4) plugify.Vector4 { var __retVal plugify.Vector4 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -2195,9 +1916,6 @@ func CallFuncVec4Callback(func_ FuncVec4) plugify.Vector4 { return __retVal } -// CallFuncMat4x4Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncMat4x4Callback(func_ FuncMat4x4) plugify.Matrix4x4 { var __retVal plugify.Matrix4x4 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -2206,9 +1924,6 @@ func CallFuncMat4x4Callback(func_ FuncMat4x4) plugify.Matrix4x4 { return __retVal } -// CallFunc1Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc1Callback(func_ Func1) int32 { var __retVal int32 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -2216,9 +1931,6 @@ func CallFunc1Callback(func_ Func1) int32 { return __retVal } -// CallFunc2Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc2Callback(func_ Func2) int8 { var __retVal int8 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -2226,16 +1938,11 @@ func CallFunc2Callback(func_ Func2) int8 { return __retVal } -// CallFunc3Callback - No description provided. -// @param func: No description available. func CallFunc3Callback(func_ Func3) { __func_ := plugify.GetFunctionPointerForDelegate(func_) C.CallFunc3Callback(__func_) } -// CallFunc4Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc4Callback(func_ Func4) plugify.Vector4 { var __retVal plugify.Vector4 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -2244,9 +1951,6 @@ func CallFunc4Callback(func_ Func4) plugify.Vector4 { return __retVal } -// CallFunc5Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc5Callback(func_ Func5) bool { var __retVal bool __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -2254,9 +1958,6 @@ func CallFunc5Callback(func_ Func5) bool { return __retVal } -// CallFunc6Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc6Callback(func_ Func6) int64 { var __retVal int64 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -2264,9 +1965,6 @@ func CallFunc6Callback(func_ Func6) int64 { return __retVal } -// CallFunc7Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc7Callback(func_ Func7) float64 { var __retVal float64 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -2274,9 +1972,6 @@ func CallFunc7Callback(func_ Func7) float64 { return __retVal } -// CallFunc8Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc8Callback(func_ Func8) plugify.Matrix4x4 { var __retVal plugify.Matrix4x4 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -2285,16 +1980,11 @@ func CallFunc8Callback(func_ Func8) plugify.Matrix4x4 { return __retVal } -// CallFunc9Callback - No description provided. -// @param func: No description available. func CallFunc9Callback(func_ Func9) { __func_ := plugify.GetFunctionPointerForDelegate(func_) C.CallFunc9Callback(__func_) } -// CallFunc10Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc10Callback(func_ Func10) uint32 { var __retVal uint32 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -2302,9 +1992,6 @@ func CallFunc10Callback(func_ Func10) uint32 { return __retVal } -// CallFunc11Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc11Callback(func_ Func11) uintptr { var __retVal uintptr __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -2312,9 +1999,6 @@ func CallFunc11Callback(func_ Func11) uintptr { return __retVal } -// CallFunc12Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc12Callback(func_ Func12) bool { var __retVal bool __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -2322,9 +2006,6 @@ func CallFunc12Callback(func_ Func12) bool { return __retVal } -// CallFunc13Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc13Callback(func_ Func13) string { var __retVal string var __retVal_native plugify.PlgString @@ -2344,9 +2025,6 @@ func CallFunc13Callback(func_ Func13) string { return __retVal } -// CallFunc14Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc14Callback(func_ Func14) []string { var __retVal []string var __retVal_native plugify.PlgVector @@ -2366,9 +2044,6 @@ func CallFunc14Callback(func_ Func14) []string { return __retVal } -// CallFunc15Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc15Callback(func_ Func15) int16 { var __retVal int16 __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -2376,9 +2051,6 @@ func CallFunc15Callback(func_ Func15) int16 { return __retVal } -// CallFunc16Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc16Callback(func_ Func16) uintptr { var __retVal uintptr __func_ := plugify.GetFunctionPointerForDelegate(func_) @@ -2386,9 +2058,6 @@ func CallFunc16Callback(func_ Func16) uintptr { return __retVal } -// CallFunc17Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc17Callback(func_ Func17) string { var __retVal string var __retVal_native plugify.PlgString @@ -2408,9 +2077,6 @@ func CallFunc17Callback(func_ Func17) string { return __retVal } -// CallFunc18Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc18Callback(func_ Func18) string { var __retVal string var __retVal_native plugify.PlgString @@ -2430,9 +2096,6 @@ func CallFunc18Callback(func_ Func18) string { return __retVal } -// CallFunc19Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc19Callback(func_ Func19) string { var __retVal string var __retVal_native plugify.PlgString @@ -2452,9 +2115,6 @@ func CallFunc19Callback(func_ Func19) string { return __retVal } -// CallFunc20Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc20Callback(func_ Func20) string { var __retVal string var __retVal_native plugify.PlgString @@ -2474,9 +2134,6 @@ func CallFunc20Callback(func_ Func20) string { return __retVal } -// CallFunc21Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc21Callback(func_ Func21) string { var __retVal string var __retVal_native plugify.PlgString @@ -2496,9 +2153,6 @@ func CallFunc21Callback(func_ Func21) string { return __retVal } -// CallFunc22Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc22Callback(func_ Func22) string { var __retVal string var __retVal_native plugify.PlgString @@ -2518,9 +2172,6 @@ func CallFunc22Callback(func_ Func22) string { return __retVal } -// CallFunc23Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc23Callback(func_ Func23) string { var __retVal string var __retVal_native plugify.PlgString @@ -2540,9 +2191,6 @@ func CallFunc23Callback(func_ Func23) string { return __retVal } -// CallFunc24Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc24Callback(func_ Func24) string { var __retVal string var __retVal_native plugify.PlgString @@ -2562,9 +2210,6 @@ func CallFunc24Callback(func_ Func24) string { return __retVal } -// CallFunc25Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc25Callback(func_ Func25) string { var __retVal string var __retVal_native plugify.PlgString @@ -2584,9 +2229,6 @@ func CallFunc25Callback(func_ Func25) string { return __retVal } -// CallFunc26Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc26Callback(func_ Func26) string { var __retVal string var __retVal_native plugify.PlgString @@ -2606,9 +2248,6 @@ func CallFunc26Callback(func_ Func26) string { return __retVal } -// CallFunc27Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc27Callback(func_ Func27) string { var __retVal string var __retVal_native plugify.PlgString @@ -2628,9 +2267,6 @@ func CallFunc27Callback(func_ Func27) string { return __retVal } -// CallFunc28Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc28Callback(func_ Func28) string { var __retVal string var __retVal_native plugify.PlgString @@ -2650,9 +2286,6 @@ func CallFunc28Callback(func_ Func28) string { return __retVal } -// CallFunc29Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc29Callback(func_ Func29) string { var __retVal string var __retVal_native plugify.PlgString @@ -2672,9 +2305,6 @@ func CallFunc29Callback(func_ Func29) string { return __retVal } -// CallFunc30Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc30Callback(func_ Func30) string { var __retVal string var __retVal_native plugify.PlgString @@ -2694,9 +2324,6 @@ func CallFunc30Callback(func_ Func30) string { return __retVal } -// CallFunc31Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc31Callback(func_ Func31) string { var __retVal string var __retVal_native plugify.PlgString @@ -2716,9 +2343,6 @@ func CallFunc31Callback(func_ Func31) string { return __retVal } -// CallFunc32Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc32Callback(func_ Func32) string { var __retVal string var __retVal_native plugify.PlgString @@ -2738,9 +2362,6 @@ func CallFunc32Callback(func_ Func32) string { return __retVal } -// CallFunc33Callback - No description provided. -// @param func: No description available. -// @return No description available. func CallFunc33Callback(func_ Func33) string { var __retVal string var __retVal_native plugify.PlgString @@ -2760,9 +2381,6 @@ func CallFunc33Callback(func_ Func33) string { return __retVal } -// CallFuncEnumCallback - No description provided. -// @param func: No description available. -// @return No description available. func CallFuncEnumCallback(func_ FuncEnum) string { var __retVal string var __retVal_native plugify.PlgString @@ -2781,3 +2399,483 @@ func CallFuncEnumCallback(func_ FuncEnum) string { }.Do() return __retVal } + +func ResourceHandleCreate(id int32, name string) uintptr { + var __retVal uintptr + __id := C.int32_t(id) + __name := plugify.ConstructString(name) + plugify.Block{ + Try: func() { + __retVal = uintptr(C.ResourceHandleCreate(__id, (*C.String)(unsafe.Pointer(&__name)))) + }, + Finally: func() { + // Perform cleanup. + plugify.DestroyString(&__name) + }, + }.Do() + return __retVal +} + +func ResourceHandleCreateDefault() uintptr { + __retVal := uintptr(C.ResourceHandleCreateDefault()) + return __retVal +} + +func ResourceHandleDestroy(handle uintptr) { + __handle := C.uintptr_t(handle) + C.ResourceHandleDestroy(__handle) +} + +func ResourceHandleGetId(handle uintptr) int32 { + var __retVal int32 + __handle := C.uintptr_t(handle) + __retVal = int32(C.ResourceHandleGetId(__handle)) + return __retVal +} + +func ResourceHandleGetName(handle uintptr) string { + var __retVal string + var __retVal_native plugify.PlgString + __handle := C.uintptr_t(handle) + plugify.Block{ + Try: func() { + __native := C.ResourceHandleGetName(__handle) + __retVal_native = *(*plugify.PlgString)(unsafe.Pointer(&__native)) + // Unmarshal - Convert native data to managed data. + __retVal = plugify.GetStringData(&__retVal_native) + }, + Finally: func() { + // Perform cleanup. + plugify.DestroyString(&__retVal_native) + }, + }.Do() + return __retVal +} + +func ResourceHandleSetName(handle uintptr, name string) { + __handle := C.uintptr_t(handle) + __name := plugify.ConstructString(name) + plugify.Block{ + Try: func() { + C.ResourceHandleSetName(__handle, (*C.String)(unsafe.Pointer(&__name))) + }, + Finally: func() { + // Perform cleanup. + plugify.DestroyString(&__name) + }, + }.Do() +} + +func ResourceHandleIncrementCounter(handle uintptr) { + __handle := C.uintptr_t(handle) + C.ResourceHandleIncrementCounter(__handle) +} + +func ResourceHandleGetCounter(handle uintptr) int32 { + var __retVal int32 + __handle := C.uintptr_t(handle) + __retVal = int32(C.ResourceHandleGetCounter(__handle)) + return __retVal +} + +func ResourceHandleAddData(handle uintptr, value float32) { + __handle := C.uintptr_t(handle) + __value := C.float(value) + C.ResourceHandleAddData(__handle, __value) +} + +func ResourceHandleGetData(handle uintptr) []float32 { + var __retVal []float32 + var __retVal_native plugify.PlgVector + __handle := C.uintptr_t(handle) + plugify.Block{ + Try: func() { + __native := C.ResourceHandleGetData(__handle) + __retVal_native = *(*plugify.PlgVector)(unsafe.Pointer(&__native)) + // Unmarshal - Convert native data to managed data. + __retVal = plugify.GetVectorDataFloat(&__retVal_native) + }, + Finally: func() { + // Perform cleanup. + plugify.DestroyVectorFloat(&__retVal_native) + }, + }.Do() + return __retVal +} + +func ResourceHandleGetAliveCount() int32 { + __retVal := int32(C.ResourceHandleGetAliveCount()) + return __retVal +} + +func ResourceHandleGetTotalCreated() int32 { + __retVal := int32(C.ResourceHandleGetTotalCreated()) + return __retVal +} + +func ResourceHandleGetTotalDestroyed() int32 { + __retVal := int32(C.ResourceHandleGetTotalDestroyed()) + return __retVal +} + +func CounterCreate(initialValue int64) uintptr { + var __retVal uintptr + __initialValue := C.int64_t(initialValue) + __retVal = uintptr(C.CounterCreate(__initialValue)) + return __retVal +} + +func CounterCreateZero() uintptr { + __retVal := uintptr(C.CounterCreateZero()) + return __retVal +} + +func CounterGetValue(counter uintptr) int64 { + var __retVal int64 + __counter := C.uintptr_t(counter) + __retVal = int64(C.CounterGetValue(__counter)) + return __retVal +} + +func CounterSetValue(counter uintptr, value int64) { + __counter := C.uintptr_t(counter) + __value := C.int64_t(value) + C.CounterSetValue(__counter, __value) +} + +func CounterIncrement(counter uintptr) { + __counter := C.uintptr_t(counter) + C.CounterIncrement(__counter) +} + +func CounterDecrement(counter uintptr) { + __counter := C.uintptr_t(counter) + C.CounterDecrement(__counter) +} + +func CounterAdd(counter uintptr, amount int64) { + __counter := C.uintptr_t(counter) + __amount := C.int64_t(amount) + C.CounterAdd(__counter, __amount) +} + +func CounterReset(counter uintptr) { + __counter := C.uintptr_t(counter) + C.CounterReset(__counter) +} + +func CounterIsPositive(counter uintptr) bool { + var __retVal bool + __counter := C.uintptr_t(counter) + __retVal = bool(C.CounterIsPositive(__counter)) + return __retVal +} + +func CounterCompare(value1 int64, value2 int64) int32 { + var __retVal int32 + __value1 := C.int64_t(value1) + __value2 := C.int64_t(value2) + __retVal = int32(C.CounterCompare(__value1, __value2)) + return __retVal +} + +func CounterSum(values []int64) int64 { + var __retVal int64 + __values := plugify.ConstructVectorInt64(values) + plugify.Block{ + Try: func() { + __retVal = int64(C.CounterSum((*C.Vector)(unsafe.Pointer(&__values)))) + }, + Finally: func() { + // Perform cleanup. + plugify.DestroyVectorInt64(&__values) + }, + }.Do() + return __retVal +} + +// noCopy prevents copying via go vet +type noCopy struct{} + +func (*noCopy) Lock() {} +func (*noCopy) Unlock() {} + +// ownership indicates whether the instance owns the underlying handle +type ownership bool + +const ( + Owned ownership = true + Borrowed ownership = false +) + +var ( + ResourceHandleErrEmptyHandle = errors.New("ResourceHandle: empty handle") +) + +// ResourceHandle - RAII wrapper for ResourceHandle pointer +type ResourceHandle struct { + handle uintptr + cleanup runtime.Cleanup + ownership ownership + noCopy noCopy +} + +func NewResourceHandleResourceHandleCreate(id int32, name string) *ResourceHandle { + return newResourceHandleOwned(ResourceHandleCreate(id, name)) +} + +func NewResourceHandleResourceHandleCreateDefault() *ResourceHandle { + return newResourceHandleOwned(ResourceHandleCreateDefault()) +} + +// newResourceHandleBorrowed creates a ResourceHandle from a borrowed handle (internal use) +func newResourceHandleBorrowed(handle uintptr) *ResourceHandle { + if handle == 0 { + return &ResourceHandle{} + } + return &ResourceHandle{ + handle: handle, + ownership: Borrowed, + } +} + +// newResourceHandleOwned creates a ResourceHandle from an owned handle (internal use) +func newResourceHandleOwned(handle uintptr) *ResourceHandle { + if handle == 0 { + return &ResourceHandle{} + } + w := &ResourceHandle{ + handle: handle, + ownership: Owned, + } + w.cleanup = runtime.AddCleanup(w, w.finalize, struct{}{}) + return w +} + +// finalize is the finalizer function (like C++ destructor) +func (w *ResourceHandle) finalize(_ struct{}) { + if plugify.Plugin.Loaded { + w.destroy() + } +} + +// destroy cleans up owned handles +func (w *ResourceHandle) destroy() { + if w.handle != 0 && w.ownership == Owned { + ResourceHandleDestroy(w.handle) + } +} + +// nullify resets the handle +func (w *ResourceHandle) nullify() { + w.handle = 0 + w.ownership = Borrowed +} + +// Close explicitly destroys the handle (like C++ destructor, but manual) +func (w *ResourceHandle) Close() { + w.Reset() +} + +// Get returns the underlying handle +func (w *ResourceHandle) Get() uintptr { + return w.handle +} + +// Release releases ownership and returns the handle +func (w *ResourceHandle) Release() uintptr { + if w.ownership == Owned { + w.cleanup.Stop() + } + handle := w.handle + w.nullify() + return handle +} + +// Reset destroys and resets the handle +func (w *ResourceHandle) Reset() { + if w.ownership == Owned { + w.cleanup.Stop() + } + w.destroy() + w.nullify() +} + +// IsValid returns true if handle is not nil +func (w *ResourceHandle) IsValid() bool { + return w.handle != 0 +} + +func (w *ResourceHandle) GetId() (int32, error) { + if w.handle == 0 { + var zero int32 + return zero, ResourceHandleErrEmptyHandle + } + return ResourceHandleGetId(w.handle), nil +} + +func (w *ResourceHandle) GetName() (string, error) { + if w.handle == 0 { + var zero string + return zero, ResourceHandleErrEmptyHandle + } + return ResourceHandleGetName(w.handle), nil +} + +func (w *ResourceHandle) SetName(name string) error { + if w.handle == 0 { + return ResourceHandleErrEmptyHandle + } + ResourceHandleSetName(w.handle, name) + return nil +} + +func (w *ResourceHandle) IncrementCounter() error { + if w.handle == 0 { + return ResourceHandleErrEmptyHandle + } + ResourceHandleIncrementCounter(w.handle) + return nil +} + +func (w *ResourceHandle) GetCounter() (int32, error) { + if w.handle == 0 { + var zero int32 + return zero, ResourceHandleErrEmptyHandle + } + return ResourceHandleGetCounter(w.handle), nil +} + +func (w *ResourceHandle) AddData(value float32) error { + if w.handle == 0 { + return ResourceHandleErrEmptyHandle + } + ResourceHandleAddData(w.handle, value) + return nil +} + +func (w *ResourceHandle) GetData() ([]float32, error) { + if w.handle == 0 { + var zero []float32 + return zero, ResourceHandleErrEmptyHandle + } + return ResourceHandleGetData(w.handle), nil +} + +func (w *ResourceHandle) GetAliveCount() (int32, error) { + return ResourceHandleGetAliveCount(), nil +} + +func (w *ResourceHandle) GetTotalCreated() (int32, error) { + return ResourceHandleGetTotalCreated(), nil +} + +func (w *ResourceHandle) GetTotalDestroyed() (int32, error) { + return ResourceHandleGetTotalDestroyed(), nil +} + +var ( + CounterErrEmptyHandle = errors.New("Counter: empty handle") +) + +type Counter struct { + handle uintptr +} + +func NewCounterCounterCreate(initialValue int64) *Counter { + return &Counter{ + handle: CounterCreate(initialValue), + } +} + +func NewCounterCounterCreateZero() *Counter { + return &Counter{ + handle: CounterCreateZero(), + } +} + +// Get returns the underlying handle +func (w *Counter) Get() uintptr { + return w.handle +} + +// Release releases ownership and returns the handle +func (w *Counter) Release() uintptr { + handle := w.handle + w.handle = 0 + return handle +} + +// Reset destroys and resets the handle +func (w *Counter) Reset() { + w.handle = 0 +} + +// IsValid returns true if handle is not nil +func (w *Counter) IsValid() bool { + return w.handle != 0 +} + +func (w *Counter) GetValue() (int64, error) { + if w.handle == 0 { + var zero int64 + return zero, CounterErrEmptyHandle + } + return CounterGetValue(w.handle), nil +} + +func (w *Counter) SetValue(value int64) error { + if w.handle == 0 { + return CounterErrEmptyHandle + } + CounterSetValue(w.handle, value) + return nil +} + +func (w *Counter) Increment() error { + if w.handle == 0 { + return CounterErrEmptyHandle + } + CounterIncrement(w.handle) + return nil +} + +func (w *Counter) Decrement() error { + if w.handle == 0 { + return CounterErrEmptyHandle + } + CounterDecrement(w.handle) + return nil +} + +func (w *Counter) Add(amount int64) error { + if w.handle == 0 { + return CounterErrEmptyHandle + } + CounterAdd(w.handle, amount) + return nil +} + +func (w *Counter) Reset2() error { + if w.handle == 0 { + return CounterErrEmptyHandle + } + CounterReset(w.handle) + return nil +} + +func (w *Counter) IsPositive() (bool, error) { + if w.handle == 0 { + var zero bool + return zero, CounterErrEmptyHandle + } + return CounterIsPositive(w.handle), nil +} + +func (w *Counter) Compare(value1 int64, value2 int64) (int32, error) { + return CounterCompare(value1, value2), nil +} + +func (w *Counter) Sum(values []int64) (int64, error) { + return CounterSum(values), nil +} diff --git a/test/cross_call_worker/cross_call_master/cross_call_master.h b/test/cross_call_worker/cross_call_master/cross_call_master.h index ed103a9..648deca 100644 --- a/test/cross_call_worker/cross_call_master/cross_call_master.h +++ b/test/cross_call_worker/cross_call_master/cross_call_master.h @@ -11,31 +11,31 @@ typedef struct Vector3 { float x, y, z; } Vector3; typedef struct Vector4 { float x, y, z, w; } Vector4; typedef struct Matrix4x4 { float m[4][4]; } Matrix4x4; typedef struct Variant { - union { - bool boolean; - char char8; - wchar_t char16; - int8_t int8; - int16_t int16; - int32_t int32; - int64_t int64; - uint8_t uint8; - uint16_t uint16; - uint32_t uint32; - uint64_t uint64; - void* ptr; - float flt; - double dbl; - String str; - Vector vec; - Vector2 vec2; - Vector3 vec3; - Vector4 vec4; - }; + union { + bool boolean; + char char8; + wchar_t char16; + int8_t int8; + int16_t int16; + int32_t int32; + int64_t int64; + uint8_t uint8; + uint16_t uint16; + uint32_t uint32; + uint64_t uint64; + void* ptr; + float flt; + double dbl; + String str; + Vector vec; + Vector2 vec2; + Vector3 vec3; + Vector4 vec4; + }; #if INTPTR_MAX == INT32_MAX volatile char pad[8]; #endif - uint8_t current; + uint8_t current; } Variant; extern void* Plugify_GetMethodPtr(const char* methodName); @@ -1055,3 +1055,172 @@ static String CallFuncEnumCallback(void* func) { if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.CallFuncEnumCallback", (void**)&__func); return __func(func); } + +static uintptr_t ResourceHandleCreate(int32_t id, String* name) { + typedef uintptr_t (*ResourceHandleCreateFn)(int32_t, String*); + static ResourceHandleCreateFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.ResourceHandleCreate", (void**)&__func); + return __func(id, name); +} + +static uintptr_t ResourceHandleCreateDefault() { + typedef uintptr_t (*ResourceHandleCreateDefaultFn)(); + static ResourceHandleCreateDefaultFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.ResourceHandleCreateDefault", (void**)&__func); + return __func(); +} + +static void ResourceHandleDestroy(uintptr_t handle) { + typedef void (*ResourceHandleDestroyFn)(uintptr_t); + static ResourceHandleDestroyFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.ResourceHandleDestroy", (void**)&__func); + __func(handle); +} + +static int32_t ResourceHandleGetId(uintptr_t handle) { + typedef int32_t (*ResourceHandleGetIdFn)(uintptr_t); + static ResourceHandleGetIdFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.ResourceHandleGetId", (void**)&__func); + return __func(handle); +} + +static String ResourceHandleGetName(uintptr_t handle) { + typedef String (*ResourceHandleGetNameFn)(uintptr_t); + static ResourceHandleGetNameFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.ResourceHandleGetName", (void**)&__func); + return __func(handle); +} + +static void ResourceHandleSetName(uintptr_t handle, String* name) { + typedef void (*ResourceHandleSetNameFn)(uintptr_t, String*); + static ResourceHandleSetNameFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.ResourceHandleSetName", (void**)&__func); + __func(handle, name); +} + +static void ResourceHandleIncrementCounter(uintptr_t handle) { + typedef void (*ResourceHandleIncrementCounterFn)(uintptr_t); + static ResourceHandleIncrementCounterFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.ResourceHandleIncrementCounter", (void**)&__func); + __func(handle); +} + +static int32_t ResourceHandleGetCounter(uintptr_t handle) { + typedef int32_t (*ResourceHandleGetCounterFn)(uintptr_t); + static ResourceHandleGetCounterFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.ResourceHandleGetCounter", (void**)&__func); + return __func(handle); +} + +static void ResourceHandleAddData(uintptr_t handle, float value) { + typedef void (*ResourceHandleAddDataFn)(uintptr_t, float); + static ResourceHandleAddDataFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.ResourceHandleAddData", (void**)&__func); + __func(handle, value); +} + +static Vector ResourceHandleGetData(uintptr_t handle) { + typedef Vector (*ResourceHandleGetDataFn)(uintptr_t); + static ResourceHandleGetDataFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.ResourceHandleGetData", (void**)&__func); + return __func(handle); +} + +static int32_t ResourceHandleGetAliveCount() { + typedef int32_t (*ResourceHandleGetAliveCountFn)(); + static ResourceHandleGetAliveCountFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.ResourceHandleGetAliveCount", (void**)&__func); + return __func(); +} + +static int32_t ResourceHandleGetTotalCreated() { + typedef int32_t (*ResourceHandleGetTotalCreatedFn)(); + static ResourceHandleGetTotalCreatedFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.ResourceHandleGetTotalCreated", (void**)&__func); + return __func(); +} + +static int32_t ResourceHandleGetTotalDestroyed() { + typedef int32_t (*ResourceHandleGetTotalDestroyedFn)(); + static ResourceHandleGetTotalDestroyedFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.ResourceHandleGetTotalDestroyed", (void**)&__func); + return __func(); +} + +static uintptr_t CounterCreate(int64_t initialValue) { + typedef uintptr_t (*CounterCreateFn)(int64_t); + static CounterCreateFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.CounterCreate", (void**)&__func); + return __func(initialValue); +} + +static uintptr_t CounterCreateZero() { + typedef uintptr_t (*CounterCreateZeroFn)(); + static CounterCreateZeroFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.CounterCreateZero", (void**)&__func); + return __func(); +} + +static int64_t CounterGetValue(uintptr_t counter) { + typedef int64_t (*CounterGetValueFn)(uintptr_t); + static CounterGetValueFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.CounterGetValue", (void**)&__func); + return __func(counter); +} + +static void CounterSetValue(uintptr_t counter, int64_t value) { + typedef void (*CounterSetValueFn)(uintptr_t, int64_t); + static CounterSetValueFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.CounterSetValue", (void**)&__func); + __func(counter, value); +} + +static void CounterIncrement(uintptr_t counter) { + typedef void (*CounterIncrementFn)(uintptr_t); + static CounterIncrementFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.CounterIncrement", (void**)&__func); + __func(counter); +} + +static void CounterDecrement(uintptr_t counter) { + typedef void (*CounterDecrementFn)(uintptr_t); + static CounterDecrementFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.CounterDecrement", (void**)&__func); + __func(counter); +} + +static void CounterAdd(uintptr_t counter, int64_t amount) { + typedef void (*CounterAddFn)(uintptr_t, int64_t); + static CounterAddFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.CounterAdd", (void**)&__func); + __func(counter, amount); +} + +static void CounterReset(uintptr_t counter) { + typedef void (*CounterResetFn)(uintptr_t); + static CounterResetFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.CounterReset", (void**)&__func); + __func(counter); +} + +static bool CounterIsPositive(uintptr_t counter) { + typedef bool (*CounterIsPositiveFn)(uintptr_t); + static CounterIsPositiveFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.CounterIsPositive", (void**)&__func); + return __func(counter); +} + +static int32_t CounterCompare(int64_t value1, int64_t value2) { + typedef int32_t (*CounterCompareFn)(int64_t, int64_t); + static CounterCompareFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.CounterCompare", (void**)&__func); + return __func(value1, value2); +} + +static int64_t CounterSum(Vector* values) { + typedef int64_t (*CounterSumFn)(Vector*); + static CounterSumFn __func = NULL; + if (__func == NULL) Plugify_GetMethodPtr2("cross_call_master.CounterSum", (void**)&__func); + return __func(values); +} + diff --git a/test/cross_call_worker/cross_call_worker.dll b/test/cross_call_worker/cross_call_worker.dll index 8d806d4..d1c6947 100644 Binary files a/test/cross_call_worker/cross_call_worker.dll and b/test/cross_call_worker/cross_call_worker.dll differ diff --git a/test/cross_call_worker/cross_call_worker.h b/test/cross_call_worker/cross_call_worker.h index c68fa82..45dcb56 100644 --- a/test/cross_call_worker/cross_call_worker.h +++ b/test/cross_call_worker/cross_call_worker.h @@ -86,151 +86,290 @@ typedef struct { void *data; GoInt len; GoInt cap; } GoSlice; extern "C" { #endif -extern void __NoParamReturnVoid(void); -extern GoUint8 __NoParamReturnBool(void); -extern GoInt8 __NoParamReturnChar8(void); -extern GoUint16 __NoParamReturnChar16(void); -extern GoInt8 __NoParamReturnInt8(void); -extern GoInt16 __NoParamReturnInt16(void); -extern GoInt32 __NoParamReturnInt32(void); -extern GoInt64 __NoParamReturnInt64(void); -extern GoUint8 __NoParamReturnUInt8(void); -extern GoUint16 __NoParamReturnUInt16(void); -extern GoUint32 __NoParamReturnUInt32(void); -extern GoUint64 __NoParamReturnUInt64(void); -extern GoUintptr __NoParamReturnPointer(void); -extern GoFloat32 __NoParamReturnFloat(void); -extern GoFloat64 __NoParamReturnDouble(void); -extern void* __NoParamReturnFunction(void); -extern String __NoParamReturnString(void); -extern Variant __NoParamReturnAny(void); -extern Vector __NoParamReturnArrayBool(void); -extern Vector __NoParamReturnArrayChar8(void); -extern Vector __NoParamReturnArrayChar16(void); -extern Vector __NoParamReturnArrayInt8(void); -extern Vector __NoParamReturnArrayInt16(void); -extern Vector __NoParamReturnArrayInt32(void); -extern Vector __NoParamReturnArrayInt64(void); -extern Vector __NoParamReturnArrayUInt8(void); -extern Vector __NoParamReturnArrayUInt16(void); -extern Vector __NoParamReturnArrayUInt32(void); -extern Vector __NoParamReturnArrayUInt64(void); -extern Vector __NoParamReturnArrayPointer(void); -extern Vector __NoParamReturnArrayFloat(void); -extern Vector __NoParamReturnArrayDouble(void); -extern Vector __NoParamReturnArrayString(void); -extern Vector __NoParamReturnArrayAny(void); -extern Vector __NoParamReturnArrayVector2(void); -extern Vector __NoParamReturnArrayVector3(void); -extern Vector __NoParamReturnArrayVector4(void); -extern Vector __NoParamReturnArrayMatrix4x4(void); -extern Vector2 __NoParamReturnVector2(void); -extern Vector3 __NoParamReturnVector3(void); -extern Vector4 __NoParamReturnVector4(void); -extern Matrix4x4 __NoParamReturnMatrix4x4(void); -extern void __Param1(GoInt32 a); -extern void __Param2(GoInt32 a, GoFloat32 b); -extern void __Param3(GoInt32 a, GoFloat32 b, GoFloat64 c); -extern void __Param4(GoInt32 a, GoFloat32 b, GoFloat64 c, Vector4* d); -extern void __Param5(GoInt32 a, GoFloat32 b, GoFloat64 c, Vector4* d, Vector* e); -extern void __Param6(GoInt32 a, GoFloat32 b, GoFloat64 c, Vector4* d, Vector* e, GoInt8 f); -extern void __Param7(GoInt32 a, GoFloat32 b, GoFloat64 c, Vector4* d, Vector* e, GoInt8 f, String* g); -extern void __Param8(GoInt32 a, GoFloat32 b, GoFloat64 c, Vector4* d, Vector* e, GoInt8 f, String* g, GoUint16 h); -extern void __Param9(GoInt32 a, GoFloat32 b, GoFloat64 c, Vector4* d, Vector* e, GoInt8 f, String* g, GoUint16 h, GoInt16 k); -extern void __Param10(GoInt32 a, GoFloat32 b, GoFloat64 c, Vector4* d, Vector* e, GoInt8 f, String* g, GoUint16 h, GoInt16 k, GoUintptr l); -extern void __ParamRef1(GoInt32* a); -extern void __ParamRef2(GoInt32* a, GoFloat32* b); -extern void __ParamRef3(GoInt32* a, GoFloat32* b, GoFloat64* c); -extern void __ParamRef4(GoInt32* a, GoFloat32* b, GoFloat64* c, Vector4* d); -extern void __ParamRef5(GoInt32* a, GoFloat32* b, GoFloat64* c, Vector4* d, Vector* e); -extern void __ParamRef6(GoInt32* a, GoFloat32* b, GoFloat64* c, Vector4* d, Vector* e, GoInt8* f); -extern void __ParamRef7(GoInt32* a, GoFloat32* b, GoFloat64* c, Vector4* d, Vector* e, GoInt8* f, String* g); -extern void __ParamRef8(GoInt32* a, GoFloat32* b, GoFloat64* c, Vector4* d, Vector* e, GoInt8* f, String* g, GoUint16* h); -extern void __ParamRef9(GoInt32* a, GoFloat32* b, GoFloat64* c, Vector4* d, Vector* e, GoInt8* f, String* g, GoUint16* h, GoInt16* k); -extern void __ParamRef10(GoInt32* a, GoFloat32* b, GoFloat64* c, Vector4* d, Vector* e, GoInt8* f, String* g, GoUint16* h, GoInt16* k, GoUintptr* l); -extern void __ParamRefVectors(Vector* p1, Vector* p2, Vector* p3, Vector* p4, Vector* p5, Vector* p6, Vector* p7, Vector* p8, Vector* p9, Vector* p10, Vector* p11, Vector* p12, Vector* p13, Vector* p14, Vector* p15); -extern GoInt64 __ParamAllPrimitives(GoUint8 p1, GoInt8 p2, GoUint16 p3, GoInt8 p4, GoInt16 p5, GoInt32 p6, GoInt64 p7, GoUint8 p8, GoUint16 p9, GoUint32 p10, GoUint64 p11, GoUintptr p12, GoFloat32 p13, GoFloat64 p14); -extern void __ParamVariant(Variant* p1, Vector* p2); -extern GoInt32 __ParamEnum(GoInt32 p1, Vector* p2); -extern GoInt32 __ParamEnumRef(GoInt32* p1, Vector* p2); -extern void __ParamVariantRef(Variant* p1, Vector* p2); -extern void __CallFuncVoid(void* func_); -extern GoUint8 __CallFuncBool(void* func_); -extern GoInt8 __CallFuncChar8(void* func_); -extern GoUint16 __CallFuncChar16(void* func_); -extern GoInt8 __CallFuncInt8(void* func_); -extern GoInt16 __CallFuncInt16(void* func_); -extern GoInt32 __CallFuncInt32(void* func_); -extern GoInt64 __CallFuncInt64(void* func_); -extern GoUint8 __CallFuncUInt8(void* func_); -extern GoUint16 __CallFuncUInt16(void* func_); -extern GoUint32 __CallFuncUInt32(void* func_); -extern GoUint64 __CallFuncUInt64(void* func_); -extern GoUintptr __CallFuncPtr(void* func_); -extern GoFloat32 __CallFuncFloat(void* func_); -extern GoFloat64 __CallFuncDouble(void* func_); -extern String __CallFuncString(void* func_); -extern Variant __CallFuncAny(void* func_); -extern GoUintptr __CallFuncFunction(void* func_); -extern Vector __CallFuncBoolVector(void* func_); -extern Vector __CallFuncChar8Vector(void* func_); -extern Vector __CallFuncChar16Vector(void* func_); -extern Vector __CallFuncInt8Vector(void* func_); -extern Vector __CallFuncInt16Vector(void* func_); -extern Vector __CallFuncInt32Vector(void* func_); -extern Vector __CallFuncInt64Vector(void* func_); -extern Vector __CallFuncUInt8Vector(void* func_); -extern Vector __CallFuncUInt16Vector(void* func_); -extern Vector __CallFuncUInt32Vector(void* func_); -extern Vector __CallFuncUInt64Vector(void* func_); -extern Vector __CallFuncPtrVector(void* func_); -extern Vector __CallFuncFloatVector(void* func_); -extern Vector __CallFuncDoubleVector(void* func_); -extern Vector __CallFuncStringVector(void* func_); -extern Vector __CallFuncAnyVector(void* func_); -extern Vector __CallFuncVec2Vector(void* func_); -extern Vector __CallFuncVec3Vector(void* func_); -extern Vector __CallFuncVec4Vector(void* func_); -extern Vector __CallFuncMat4x4Vector(void* func_); -extern Vector2 __CallFuncVec2(void* func_); -extern Vector3 __CallFuncVec3(void* func_); -extern Vector4 __CallFuncVec4(void* func_); -extern Matrix4x4 __CallFuncMat4x4(void* func_); -extern GoInt32 __CallFunc1(void* func_); -extern GoInt8 __CallFunc2(void* func_); -extern void __CallFunc3(void* func_); -extern Vector4 __CallFunc4(void* func_); -extern GoUint8 __CallFunc5(void* func_); -extern GoInt64 __CallFunc6(void* func_); -extern GoFloat64 __CallFunc7(void* func_); -extern Matrix4x4 __CallFunc8(void* func_); -extern void __CallFunc9(void* func_); -extern GoUint32 __CallFunc10(void* func_); -extern GoUintptr __CallFunc11(void* func_); -extern GoUint8 __CallFunc12(void* func_); -extern String __CallFunc13(void* func_); -extern Vector __CallFunc14(void* func_); -extern GoInt16 __CallFunc15(void* func_); -extern GoUintptr __CallFunc16(void* func_); -extern String __CallFunc17(void* func_); -extern String __CallFunc18(void* func_); -extern String __CallFunc19(void* func_); -extern String __CallFunc20(void* func_); -extern String __CallFunc21(void* func_); -extern String __CallFunc22(void* func_); -extern String __CallFunc23(void* func_); -extern String __CallFunc24(void* func_); -extern String __CallFunc25(void* func_); -extern String __CallFunc26(void* func_); -extern String __CallFunc27(void* func_); -extern String __CallFunc28(void* func_); -extern String __CallFunc29(void* func_); -extern String __CallFunc30(void* func_); -extern String __CallFunc31(void* func_); -extern String __CallFunc32(void* func_); -extern String __CallFunc33(void* func_); -extern String __CallFuncEnum(void* func_); -extern void __ReverseCall(String* test); +extern __declspec(dllexport) void __NoParamReturnVoid(void); +extern __declspec(dllexport) GoUint8 __NoParamReturnBool(void); +extern __declspec(dllexport) GoInt8 __NoParamReturnChar8(void); +extern __declspec(dllexport) GoUint16 __NoParamReturnChar16(void); +extern __declspec(dllexport) GoInt8 __NoParamReturnInt8(void); +extern __declspec(dllexport) GoInt16 __NoParamReturnInt16(void); +extern __declspec(dllexport) GoInt32 __NoParamReturnInt32(void); +extern __declspec(dllexport) GoInt64 __NoParamReturnInt64(void); +extern __declspec(dllexport) GoUint8 __NoParamReturnUInt8(void); +extern __declspec(dllexport) GoUint16 __NoParamReturnUInt16(void); +extern __declspec(dllexport) GoUint32 __NoParamReturnUInt32(void); +extern __declspec(dllexport) GoUint64 __NoParamReturnUInt64(void); +extern __declspec(dllexport) GoUintptr __NoParamReturnPointer(void); +extern __declspec(dllexport) GoFloat32 __NoParamReturnFloat(void); +extern __declspec(dllexport) GoFloat64 __NoParamReturnDouble(void); +extern __declspec(dllexport) void* __NoParamReturnFunction(void); +extern __declspec(dllexport) String __NoParamReturnString(void); +extern __declspec(dllexport) Variant __NoParamReturnAny(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayBool(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayChar8(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayChar16(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayInt8(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayInt16(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayInt32(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayInt64(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayUInt8(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayUInt16(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayUInt32(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayUInt64(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayPointer(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayFloat(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayDouble(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayString(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayAny(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayVector2(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayVector3(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayVector4(void); +extern __declspec(dllexport) Vector __NoParamReturnArrayMatrix4x4(void); +extern __declspec(dllexport) Vector2 __NoParamReturnVector2(void); +extern __declspec(dllexport) Vector3 __NoParamReturnVector3(void); +extern __declspec(dllexport) Vector4 __NoParamReturnVector4(void); +extern __declspec(dllexport) Matrix4x4 __NoParamReturnMatrix4x4(void); +extern __declspec(dllexport) void __Param1(GoInt32 a); +extern __declspec(dllexport) void __Param2(GoInt32 a, GoFloat32 b); +extern __declspec(dllexport) void __Param3(GoInt32 a, GoFloat32 b, GoFloat64 c); +extern __declspec(dllexport) void __Param4(GoInt32 a, GoFloat32 b, GoFloat64 c, Vector4* d); +extern __declspec(dllexport) void __Param5(GoInt32 a, GoFloat32 b, GoFloat64 c, Vector4* d, Vector* e); +extern __declspec(dllexport) void __Param6(GoInt32 a, GoFloat32 b, GoFloat64 c, Vector4* d, Vector* e, GoInt8 f); +extern __declspec(dllexport) void __Param7(GoInt32 a, GoFloat32 b, GoFloat64 c, Vector4* d, Vector* e, GoInt8 f, String* g); +extern __declspec(dllexport) void __Param8(GoInt32 a, GoFloat32 b, GoFloat64 c, Vector4* d, Vector* e, GoInt8 f, String* g, GoUint16 h); +extern __declspec(dllexport) void __Param9(GoInt32 a, GoFloat32 b, GoFloat64 c, Vector4* d, Vector* e, GoInt8 f, String* g, GoUint16 h, GoInt16 k); +extern __declspec(dllexport) void __Param10(GoInt32 a, GoFloat32 b, GoFloat64 c, Vector4* d, Vector* e, GoInt8 f, String* g, GoUint16 h, GoInt16 k, GoUintptr l); +extern __declspec(dllexport) void __ParamRef1(GoInt32* a); +extern __declspec(dllexport) void __ParamRef2(GoInt32* a, GoFloat32* b); +extern __declspec(dllexport) void __ParamRef3(GoInt32* a, GoFloat32* b, GoFloat64* c); +extern __declspec(dllexport) void __ParamRef4(GoInt32* a, GoFloat32* b, GoFloat64* c, Vector4* d); +extern __declspec(dllexport) void __ParamRef5(GoInt32* a, GoFloat32* b, GoFloat64* c, Vector4* d, Vector* e); +extern __declspec(dllexport) void __ParamRef6(GoInt32* a, GoFloat32* b, GoFloat64* c, Vector4* d, Vector* e, GoInt8* f); +extern __declspec(dllexport) void __ParamRef7(GoInt32* a, GoFloat32* b, GoFloat64* c, Vector4* d, Vector* e, GoInt8* f, String* g); +extern __declspec(dllexport) void __ParamRef8(GoInt32* a, GoFloat32* b, GoFloat64* c, Vector4* d, Vector* e, GoInt8* f, String* g, GoUint16* h); +extern __declspec(dllexport) void __ParamRef9(GoInt32* a, GoFloat32* b, GoFloat64* c, Vector4* d, Vector* e, GoInt8* f, String* g, GoUint16* h, GoInt16* k); +extern __declspec(dllexport) void __ParamRef10(GoInt32* a, GoFloat32* b, GoFloat64* c, Vector4* d, Vector* e, GoInt8* f, String* g, GoUint16* h, GoInt16* k, GoUintptr* l); +extern __declspec(dllexport) void __ParamRefVectors(Vector* p1, Vector* p2, Vector* p3, Vector* p4, Vector* p5, Vector* p6, Vector* p7, Vector* p8, Vector* p9, Vector* p10, Vector* p11, Vector* p12, Vector* p13, Vector* p14, Vector* p15); +extern __declspec(dllexport) GoInt64 __ParamAllPrimitives(GoUint8 p1, GoInt8 p2, GoUint16 p3, GoInt8 p4, GoInt16 p5, GoInt32 p6, GoInt64 p7, GoUint8 p8, GoUint16 p9, GoUint32 p10, GoUint64 p11, GoUintptr p12, GoFloat32 p13, GoFloat64 p14); +extern __declspec(dllexport) GoInt32 __ParamEnum(GoInt32 p1, Vector* p2); +extern __declspec(dllexport) GoInt32 __ParamEnumRef(GoInt32* p1, Vector* p2); +extern __declspec(dllexport) void __ParamVariant(Variant* p1, Vector* p2); +extern __declspec(dllexport) void __ParamVariantRef(Variant* p1, Vector* p2); +extern __declspec(dllexport) void __CallFuncVoid(void* func_); +extern __declspec(dllexport) GoUint8 __CallFuncBool(void* func_); +extern __declspec(dllexport) GoInt8 __CallFuncChar8(void* func_); +extern __declspec(dllexport) GoUint16 __CallFuncChar16(void* func_); +extern __declspec(dllexport) GoInt8 __CallFuncInt8(void* func_); +extern __declspec(dllexport) GoInt16 __CallFuncInt16(void* func_); +extern __declspec(dllexport) GoInt32 __CallFuncInt32(void* func_); +extern __declspec(dllexport) GoInt64 __CallFuncInt64(void* func_); +extern __declspec(dllexport) GoUint8 __CallFuncUInt8(void* func_); +extern __declspec(dllexport) GoUint16 __CallFuncUInt16(void* func_); +extern __declspec(dllexport) GoUint32 __CallFuncUInt32(void* func_); +extern __declspec(dllexport) GoUint64 __CallFuncUInt64(void* func_); +extern __declspec(dllexport) GoUintptr __CallFuncPtr(void* func_); +extern __declspec(dllexport) GoFloat32 __CallFuncFloat(void* func_); +extern __declspec(dllexport) GoFloat64 __CallFuncDouble(void* func_); +extern __declspec(dllexport) GoUintptr __CallFuncFunction(void* func_); +extern __declspec(dllexport) String __CallFuncString(void* func_); +extern __declspec(dllexport) Variant __CallFuncAny(void* func_); +extern __declspec(dllexport) Vector __CallFuncBoolVector(void* func_); +extern __declspec(dllexport) Vector __CallFuncChar8Vector(void* func_); +extern __declspec(dllexport) Vector __CallFuncChar16Vector(void* func_); +extern __declspec(dllexport) Vector __CallFuncInt8Vector(void* func_); +extern __declspec(dllexport) Vector __CallFuncInt16Vector(void* func_); +extern __declspec(dllexport) Vector __CallFuncInt32Vector(void* func_); +extern __declspec(dllexport) Vector __CallFuncInt64Vector(void* func_); +extern __declspec(dllexport) Vector __CallFuncUInt8Vector(void* func_); +extern __declspec(dllexport) Vector __CallFuncUInt16Vector(void* func_); +extern __declspec(dllexport) Vector __CallFuncUInt32Vector(void* func_); +extern __declspec(dllexport) Vector __CallFuncUInt64Vector(void* func_); +extern __declspec(dllexport) Vector __CallFuncPtrVector(void* func_); +extern __declspec(dllexport) Vector __CallFuncFloatVector(void* func_); +extern __declspec(dllexport) Vector __CallFuncDoubleVector(void* func_); +extern __declspec(dllexport) Vector __CallFuncStringVector(void* func_); +extern __declspec(dllexport) Vector __CallFuncAnyVector(void* func_); +extern __declspec(dllexport) Vector __CallFuncVec2Vector(void* func_); +extern __declspec(dllexport) Vector __CallFuncVec3Vector(void* func_); +extern __declspec(dllexport) Vector __CallFuncVec4Vector(void* func_); +extern __declspec(dllexport) Vector __CallFuncMat4x4Vector(void* func_); +extern __declspec(dllexport) Vector2 __CallFuncVec2(void* func_); +extern __declspec(dllexport) Vector3 __CallFuncVec3(void* func_); +extern __declspec(dllexport) Vector4 __CallFuncVec4(void* func_); +extern __declspec(dllexport) Matrix4x4 __CallFuncMat4x4(void* func_); +extern __declspec(dllexport) GoInt32 __CallFunc1(void* func_); +extern __declspec(dllexport) GoInt8 __CallFunc2(void* func_); +extern __declspec(dllexport) void __CallFunc3(void* func_); +extern __declspec(dllexport) Vector4 __CallFunc4(void* func_); +extern __declspec(dllexport) GoUint8 __CallFunc5(void* func_); +extern __declspec(dllexport) GoInt64 __CallFunc6(void* func_); +extern __declspec(dllexport) GoFloat64 __CallFunc7(void* func_); +extern __declspec(dllexport) Matrix4x4 __CallFunc8(void* func_); +extern __declspec(dllexport) void __CallFunc9(void* func_); +extern __declspec(dllexport) GoUint32 __CallFunc10(void* func_); +extern __declspec(dllexport) GoUintptr __CallFunc11(void* func_); +extern __declspec(dllexport) GoUint8 __CallFunc12(void* func_); +extern __declspec(dllexport) String __CallFunc13(void* func_); +extern __declspec(dllexport) Vector __CallFunc14(void* func_); +extern __declspec(dllexport) GoInt16 __CallFunc15(void* func_); +extern __declspec(dllexport) GoUintptr __CallFunc16(void* func_); +extern __declspec(dllexport) String __CallFunc17(void* func_); +extern __declspec(dllexport) String __CallFunc18(void* func_); +extern __declspec(dllexport) String __CallFunc19(void* func_); +extern __declspec(dllexport) String __CallFunc20(void* func_); +extern __declspec(dllexport) String __CallFunc21(void* func_); +extern __declspec(dllexport) String __CallFunc22(void* func_); +extern __declspec(dllexport) String __CallFunc23(void* func_); +extern __declspec(dllexport) String __CallFunc24(void* func_); +extern __declspec(dllexport) String __CallFunc25(void* func_); +extern __declspec(dllexport) String __CallFunc26(void* func_); +extern __declspec(dllexport) String __CallFunc27(void* func_); +extern __declspec(dllexport) String __CallFunc28(void* func_); +extern __declspec(dllexport) String __CallFunc29(void* func_); +extern __declspec(dllexport) String __CallFunc30(void* func_); +extern __declspec(dllexport) String __CallFunc31(void* func_); +extern __declspec(dllexport) String __CallFunc32(void* func_); +extern __declspec(dllexport) String __CallFunc33(void* func_); +extern __declspec(dllexport) String __CallFuncEnum(void* func_); +extern __declspec(dllexport) String __ReverseNoParamReturnVoid(void); +extern __declspec(dllexport) String __ReverseNoParamReturnBool(void); +extern __declspec(dllexport) String __ReverseNoParamReturnChar8(void); +extern __declspec(dllexport) String __ReverseNoParamReturnChar16(void); +extern __declspec(dllexport) String __ReverseNoParamReturnInt8(void); +extern __declspec(dllexport) String __ReverseNoParamReturnInt16(void); +extern __declspec(dllexport) String __ReverseNoParamReturnInt32(void); +extern __declspec(dllexport) String __ReverseNoParamReturnInt64(void); +extern __declspec(dllexport) String __ReverseNoParamReturnUInt8(void); +extern __declspec(dllexport) String __ReverseNoParamReturnUInt16(void); +extern __declspec(dllexport) String __ReverseNoParamReturnUInt32(void); +extern __declspec(dllexport) String __ReverseNoParamReturnUInt64(void); +extern __declspec(dllexport) String __ReverseNoParamReturnPointer(void); +extern __declspec(dllexport) String __ReverseNoParamReturnFloat(void); +extern __declspec(dllexport) String __ReverseNoParamReturnDouble(void); +extern __declspec(dllexport) String __ReverseNoParamReturnFunction(void); +extern __declspec(dllexport) String __ReverseNoParamReturnString(void); +extern __declspec(dllexport) String __ReverseNoParamReturnAny(void); +extern __declspec(dllexport) String __ReverseNoParamReturnArrayBool(void); +extern __declspec(dllexport) String __ReverseNoParamReturnArrayChar8(void); +extern __declspec(dllexport) String __ReverseNoParamReturnArrayChar16(void); +extern __declspec(dllexport) String __ReverseNoParamReturnArrayInt8(void); +extern __declspec(dllexport) String __ReverseNoParamReturnArrayInt16(void); +extern __declspec(dllexport) String __ReverseNoParamReturnArrayInt32(void); +extern __declspec(dllexport) String __ReverseNoParamReturnArrayInt64(void); +extern __declspec(dllexport) String __ReverseNoParamReturnArrayUInt8(void); +extern __declspec(dllexport) String __ReverseNoParamReturnArrayUInt16(void); +extern __declspec(dllexport) String __ReverseNoParamReturnArrayUInt32(void); +extern __declspec(dllexport) String __ReverseNoParamReturnArrayUInt64(void); +extern __declspec(dllexport) String __ReverseNoParamReturnArrayPointer(void); +extern __declspec(dllexport) String __ReverseNoParamReturnArrayFloat(void); +extern __declspec(dllexport) String __ReverseNoParamReturnArrayDouble(void); +extern __declspec(dllexport) String __ReverseNoParamReturnArrayString(void); +extern __declspec(dllexport) String __ReverseNoParamReturnArrayAny(void); +extern __declspec(dllexport) String __ReverseNoParamReturnVector2(void); +extern __declspec(dllexport) String __ReverseNoParamReturnVector3(void); +extern __declspec(dllexport) String __ReverseNoParamReturnVector4(void); +extern __declspec(dllexport) String __ReverseNoParamReturnMatrix4x4(void); +extern __declspec(dllexport) String __ReverseParam1(void); +extern __declspec(dllexport) String __ReverseParam2(void); +extern __declspec(dllexport) String __ReverseParam3(void); +extern __declspec(dllexport) String __ReverseParam4(void); +extern __declspec(dllexport) String __ReverseParam5(void); +extern __declspec(dllexport) String __ReverseParam6(void); +extern __declspec(dllexport) String __ReverseParam7(void); +extern __declspec(dllexport) String __ReverseParam8(void); +extern __declspec(dllexport) String __ReverseParam9(void); +extern __declspec(dllexport) String __ReverseParam10(void); +extern __declspec(dllexport) String __ReverseParamRef1(void); +extern __declspec(dllexport) String __ReverseParamRef2(void); +extern __declspec(dllexport) String __ReverseParamRef3(void); +extern __declspec(dllexport) String __ReverseParamRef4(void); +extern __declspec(dllexport) String __ReverseParamRef5(void); +extern __declspec(dllexport) String __ReverseParamRef6(void); +extern __declspec(dllexport) String __ReverseParamRef7(void); +extern __declspec(dllexport) String __ReverseParamRef8(void); +extern __declspec(dllexport) String __ReverseParamRef9(void); +extern __declspec(dllexport) String __ReverseParamRef10(void); +extern __declspec(dllexport) String __ReverseParamRefVectors(void); +extern __declspec(dllexport) String __ReverseParamAllPrimitives(void); +extern __declspec(dllexport) String __ReverseParamEnum(void); +extern __declspec(dllexport) String __ReverseParamEnumRef(void); +extern __declspec(dllexport) String __ReverseParamVariant(void); +extern __declspec(dllexport) String __ReverseParamVariantRef(void); +extern __declspec(dllexport) String __ReverseCallFuncVoid(void); +extern __declspec(dllexport) String __ReverseCallFuncBool(void); +extern __declspec(dllexport) String __ReverseCallFuncChar8(void); +extern __declspec(dllexport) String __ReverseCallFuncChar16(void); +extern __declspec(dllexport) String __ReverseCallFuncInt8(void); +extern __declspec(dllexport) String __ReverseCallFuncInt16(void); +extern __declspec(dllexport) String __ReverseCallFuncInt32(void); +extern __declspec(dllexport) String __ReverseCallFuncInt64(void); +extern __declspec(dllexport) String __ReverseCallFuncUInt8(void); +extern __declspec(dllexport) String __ReverseCallFuncUInt16(void); +extern __declspec(dllexport) String __ReverseCallFuncUInt32(void); +extern __declspec(dllexport) String __ReverseCallFuncUInt64(void); +extern __declspec(dllexport) String __ReverseCallFuncPtr(void); +extern __declspec(dllexport) String __ReverseCallFuncFloat(void); +extern __declspec(dllexport) String __ReverseCallFuncDouble(void); +extern __declspec(dllexport) String __ReverseCallFuncString(void); +extern __declspec(dllexport) String __ReverseCallFuncAny(void); +extern __declspec(dllexport) String __ReverseCallFuncBoolVector(void); +extern __declspec(dllexport) String __ReverseCallFuncChar8Vector(void); +extern __declspec(dllexport) String __ReverseCallFuncChar16Vector(void); +extern __declspec(dllexport) String __ReverseCallFuncInt8Vector(void); +extern __declspec(dllexport) String __ReverseCallFuncInt16Vector(void); +extern __declspec(dllexport) String __ReverseCallFuncInt32Vector(void); +extern __declspec(dllexport) String __ReverseCallFuncInt64Vector(void); +extern __declspec(dllexport) String __ReverseCallFuncUInt8Vector(void); +extern __declspec(dllexport) String __ReverseCallFuncUInt16Vector(void); +extern __declspec(dllexport) String __ReverseCallFuncUInt32Vector(void); +extern __declspec(dllexport) String __ReverseCallFuncUInt64Vector(void); +extern __declspec(dllexport) String __ReverseCallFuncPtrVector(void); +extern __declspec(dllexport) String __ReverseCallFuncFloatVector(void); +extern __declspec(dllexport) String __ReverseCallFuncDoubleVector(void); +extern __declspec(dllexport) String __ReverseCallFuncStringVector(void); +extern __declspec(dllexport) String __ReverseCallFuncAnyVector(void); +extern __declspec(dllexport) String __ReverseCallFuncVec2Vector(void); +extern __declspec(dllexport) String __ReverseCallFuncVec3Vector(void); +extern __declspec(dllexport) String __ReverseCallFuncVec4Vector(void); +extern __declspec(dllexport) String __ReverseCallFuncMat4x4Vector(void); +extern __declspec(dllexport) String __ReverseCallFuncVec2(void); +extern __declspec(dllexport) String __ReverseCallFuncVec3(void); +extern __declspec(dllexport) String __ReverseCallFuncVec4(void); +extern __declspec(dllexport) String __ReverseCallFuncMat4x4(void); +extern __declspec(dllexport) String __ReverseCallFunc1(void); +extern __declspec(dllexport) String __ReverseCallFunc2(void); +extern __declspec(dllexport) String __ReverseCallFunc3(void); +extern __declspec(dllexport) String __ReverseCallFunc4(void); +extern __declspec(dllexport) String __ReverseCallFunc5(void); +extern __declspec(dllexport) String __ReverseCallFunc6(void); +extern __declspec(dllexport) String __ReverseCallFunc7(void); +extern __declspec(dllexport) String __ReverseCallFunc8(void); +extern __declspec(dllexport) String __ReverseCallFunc9(void); +extern __declspec(dllexport) String __ReverseCallFunc10(void); +extern __declspec(dllexport) String __ReverseCallFunc11(void); +extern __declspec(dllexport) String __ReverseCallFunc12(void); +extern __declspec(dllexport) String __ReverseCallFunc13(void); +extern __declspec(dllexport) String __ReverseCallFunc14(void); +extern __declspec(dllexport) String __ReverseCallFunc15(void); +extern __declspec(dllexport) String __ReverseCallFunc16(void); +extern __declspec(dllexport) String __ReverseCallFunc17(void); +extern __declspec(dllexport) String __ReverseCallFunc18(void); +extern __declspec(dllexport) String __ReverseCallFunc19(void); +extern __declspec(dllexport) String __ReverseCallFunc20(void); +extern __declspec(dllexport) String __ReverseCallFunc21(void); +extern __declspec(dllexport) String __ReverseCallFunc22(void); +extern __declspec(dllexport) String __ReverseCallFunc23(void); +extern __declspec(dllexport) String __ReverseCallFunc24(void); +extern __declspec(dllexport) String __ReverseCallFunc25(void); +extern __declspec(dllexport) String __ReverseCallFunc26(void); +extern __declspec(dllexport) String __ReverseCallFunc27(void); +extern __declspec(dllexport) String __ReverseCallFunc28(void); +extern __declspec(dllexport) String __ReverseCallFunc29(void); +extern __declspec(dllexport) String __ReverseCallFunc30(void); +extern __declspec(dllexport) String __ReverseCallFunc31(void); +extern __declspec(dllexport) String __ReverseCallFunc32(void); +extern __declspec(dllexport) String __ReverseCallFunc33(void); +extern __declspec(dllexport) String __ReverseCallFuncEnum(void); +extern __declspec(dllexport) void __ReverseCall(String* test); #ifdef __cplusplus } diff --git a/test/cross_call_worker/exports.go b/test/cross_call_worker/exports.go new file mode 100644 index 0000000..70abeab --- /dev/null +++ b/test/cross_call_worker/exports.go @@ -0,0 +1,2789 @@ +package main + +import ( + "fmt" + "math" + "plugify-plugin/cross_call_master" + "runtime" + "strconv" + "strings" + "unsafe" + + "github.com/untrustedmodders/go-plugify" +) + +type Example = int32 + +const ( + First Example = 1 + Second Example = 2 + Third Example = 3 + Forth Example = 4 +) + +type NoParamReturnFunctionFunc func() +type FuncVoid func() +type FuncBool func() bool +type FuncChar8 func() int8 +type FuncChar16 func() uint16 +type FuncInt8 func() int8 +type FuncInt16 func() int16 +type FuncInt32 func() int32 +type FuncInt64 func() int64 +type FuncUInt8 func() uint8 +type FuncUInt16 func() uint16 +type FuncUInt32 func() uint32 +type FuncUInt64 func() uint64 +type FuncPtr func() uintptr +type FuncFloat func() float32 +type FuncDouble func() float64 +type FuncString func() string +type FuncAny func() any +type FuncFunction func() uintptr +type FuncBoolVector func() []bool +type FuncChar8Vector func() []int8 +type FuncChar16Vector func() []uint16 +type FuncInt8Vector func() []int8 +type FuncInt16Vector func() []int16 +type FuncInt32Vector func() []int32 +type FuncInt64Vector func() []int64 +type FuncUInt8Vector func() []uint8 +type FuncUInt16Vector func() []uint16 +type FuncUInt32Vector func() []uint32 +type FuncUInt64Vector func() []uint64 +type FuncPtrVector func() []uintptr +type FuncFloatVector func() []float32 +type FuncDoubleVector func() []float64 +type FuncStringVector func() []string +type FuncAnyVector func() []any +type FuncVec2Vector func() []plugify.Vector2 +type FuncVec3Vector func() []plugify.Vector3 +type FuncVec4Vector func() []plugify.Vector4 +type FuncMat4x4Vector func() []plugify.Matrix4x4 +type FuncVec2 func() plugify.Vector2 +type FuncVec3 func() plugify.Vector3 +type FuncVec4 func() plugify.Vector4 +type FuncMat4x4 func() plugify.Matrix4x4 +type Func1 func(*plugify.Vector3) int32 +type Func2 func(float32, int64) int8 +type Func3 func(uintptr, *plugify.Vector4, string) +type Func4 func(bool, int32, uint16, *plugify.Matrix4x4) plugify.Vector4 +type Func5 func(int8, *plugify.Vector2, uintptr, float64, []uint64) bool +type Func6 func(string, float32, []float32, int16, []uint8, uintptr) int64 +type Func7 func([]int8, uint16, uint16, []uint32, *plugify.Vector4, bool, uint64) float64 +type Func8 func(*plugify.Vector3, []uint32, int16, bool, *plugify.Vector4, []uint16, uint16, int32) plugify.Matrix4x4 +type Func9 func(float32, *plugify.Vector2, []int8, uint64, bool, string, *plugify.Vector4, int16, uintptr) +type Func10 func(*plugify.Vector4, *plugify.Matrix4x4, []uint32, uint64, []int8, int32, bool, *plugify.Vector2, int64, float64) uint32 +type Func11 func([]bool, uint16, uint8, float64, *plugify.Vector3, []int8, int64, uint16, float32, *plugify.Vector2, uint32) uintptr +type Func12 func(uintptr, []float64, uint32, float64, bool, int32, int8, uint64, float32, []uintptr, int64, int8) bool +type Func13 func(int64, []int8, uint16, float32, []bool, *plugify.Vector4, string, int32, *plugify.Vector3, uintptr, *plugify.Vector2, []uint8, int16) string +type Func14 func([]int8, []uint32, *plugify.Matrix4x4, bool, uint16, int32, []float32, uint16, []uint8, int8, *plugify.Vector3, *plugify.Vector4, float64, uintptr) []string +type Func15 func([]int16, *plugify.Matrix4x4, *plugify.Vector4, uintptr, uint64, []uint32, bool, float32, []uint16, uint8, int32, *plugify.Vector2, uint16, float64, []uint8) int16 +type Func16 func([]bool, int16, []int8, *plugify.Vector4, *plugify.Matrix4x4, *plugify.Vector2, []uint64, []int8, string, int64, []uint32, *plugify.Vector3, float32, float64, int8, uint16) uintptr +type Func17 func(*int32) +type Func18 func(*int8, *int16) plugify.Vector2 +type Func19 func(*uint32, *plugify.Vector3, *[]uint32) +type Func20 func(*uint16, *plugify.Vector4, *[]uint64, *int8) int32 +type Func21 func(*plugify.Matrix4x4, *[]int32, *plugify.Vector2, *bool, *float64) float32 +type Func22 func(*uintptr, *uint32, *[]float64, *int16, *string, *plugify.Vector4) uint64 +type Func23 func(*uint64, *plugify.Vector2, *[]int16, *uint16, *float32, *int8, *[]uint8) +type Func24 func(*[]int8, *int64, *[]uint8, *plugify.Vector4, *uint64, *[]uintptr, *float64, *[]uintptr) plugify.Matrix4x4 +type Func25 func(*int32, *[]uintptr, *bool, *uint8, *string, *plugify.Vector3, *int64, *plugify.Vector4, *uint16) float64 +type Func26 func(*uint16, *plugify.Vector2, *plugify.Matrix4x4, *[]float32, *int16, *uint64, *uint32, *[]uint16, *uintptr, *bool) int8 +type Func27 func(*float32, *plugify.Vector3, *uintptr, *plugify.Vector2, *[]int16, *plugify.Matrix4x4, *bool, *plugify.Vector4, *int8, *int32, *[]uint8) uint8 +type Func28 func(*uintptr, *uint16, *[]uint32, *plugify.Matrix4x4, *float32, *plugify.Vector4, *string, *[]uint64, *int64, *bool, *plugify.Vector3, *[]float32) string +type Func29 func(*plugify.Vector4, *int32, *[]int8, *float64, *bool, *int8, *[]uint16, *float32, *string, *plugify.Matrix4x4, *uint64, *plugify.Vector3, *[]int64) []string +type Func30 func(*uintptr, *plugify.Vector4, *int64, *[]uint32, *bool, *string, *plugify.Vector3, *[]uint8, *float32, *plugify.Vector2, *plugify.Matrix4x4, *int8, *[]float32, *float64) int32 +type Func31 func(*int8, *uint32, *[]uint64, *plugify.Vector4, *string, *bool, *int64, *plugify.Vector2, *int8, *uint16, *[]int16, *plugify.Matrix4x4, *plugify.Vector3, *float32, *[]float64) plugify.Vector3 +type Func32 func(*int32, *uint16, *[]int8, *plugify.Vector4, *uintptr, *[]uint32, *plugify.Matrix4x4, *uint64, *string, *int64, *plugify.Vector2, *[]int8, *bool, *plugify.Vector3, *uint8, *[]uint16) +type Func33 func(*any) +type FuncEnum func(Example, *[]Example) []Example + +// plugify:export NoParamReturnVoid +func NoParamReturnVoid() { + fmt.Println("Go: NoParamReturnVoid") +} + +// plugify:export NoParamReturnBool +func NoParamReturnBool() bool { + fmt.Println("Go: NoParamReturnBool") + return true +} + +// plugify:export NoParamReturnChar8 +func NoParamReturnChar8() int8 { + fmt.Println("Go: NoParamReturnChar16") + return math.MaxInt8 +} + +// plugify:export NoParamReturnChar16 +func NoParamReturnChar16() uint16 { + fmt.Println("Go: NoParamReturnChar16") + return math.MaxUint16 +} + +// plugify:export NoParamReturnInt8 +func NoParamReturnInt8() int8 { + fmt.Println("Go: NoParamReturnInt8") + return math.MaxInt8 +} + +// plugify:export NoParamReturnInt16 +func NoParamReturnInt16() int16 { + fmt.Println("Go: NoParamReturnInt16") + return math.MaxInt16 +} + +// plugify:export NoParamReturnInt32 +func NoParamReturnInt32() int32 { + fmt.Println("Go: NoParamReturnInt32") + return math.MaxInt32 +} + +// plugify:export NoParamReturnInt64 +func NoParamReturnInt64() int64 { + fmt.Println("Go: NoParamReturnInt64") + return math.MaxInt64 +} + +// plugify:export NoParamReturnUInt8 +func NoParamReturnUInt8() uint8 { + fmt.Println("Go: NoParamReturnUInt8") + return math.MaxUint8 +} + +// plugify:export NoParamReturnUInt16 +func NoParamReturnUInt16() uint16 { + fmt.Println("Go: NoParamReturnUInt16") + return math.MaxUint16 +} + +// plugify:export NoParamReturnUInt32 +func NoParamReturnUInt32() uint32 { + fmt.Println("Go: NoParamReturnUInt32") + return math.MaxUint32 +} + +// plugify:export NoParamReturnUInt64 +func NoParamReturnUInt64() uint64 { + fmt.Println("Go: NoParamReturnUInt64") + return math.MaxUint64 +} + +// plugify:export NoParamReturnPointer +func NoParamReturnPointer() uintptr { + fmt.Println("Go: NoParamReturnPointer") + return uintptr(1) +} + +// plugify:export NoParamReturnFloat +func NoParamReturnFloat() float32 { + fmt.Println("Go: NoParamReturnFloat") + return math.MaxFloat32 +} + +// plugify:export NoParamReturnDouble +func NoParamReturnDouble() float64 { + fmt.Println("Go: NoParamReturnDouble") + return math.MaxFloat64 +} + +// plugify:export NoParamReturnFunction +func NoParamReturnFunction() NoParamReturnFunctionFunc { + fmt.Println("Go: NoParamReturnFunction") + return func() { + fmt.Println("Go: NoParamReturnFunctionFunc") + } +} + +// plugify:export NoParamReturnString +func NoParamReturnString() string { + fmt.Println("Go: NoParamReturnString") + return "Hello World" +} + +// plugify:export NoParamReturnAny +func NoParamReturnAny() any { + fmt.Println("NoParamReturnAny") + return []float64{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0} +} + +// plugify:export NoParamReturnArrayBool +func NoParamReturnArrayBool() []bool { + fmt.Println("Go: NoParamReturnArrayBool") + return []bool{true, false} +} + +// plugify:export NoParamReturnArrayChar8 +func NoParamReturnArrayChar8() []int8 { + fmt.Println("Go: NoParamReturnArrayChar8") + return []int8{'a', 'b', 'c', 'd'} +} + +// plugify:export NoParamReturnArrayChar16 +func NoParamReturnArrayChar16() []uint16 { + fmt.Println("Go: NoParamReturnArrayChar16") + return []uint16{'a', 'b', 'c', 'd'} +} + +// plugify:export NoParamReturnArrayInt8 +func NoParamReturnArrayInt8() []int8 { + fmt.Println("Go: NoParamReturnArrayInt8") + return []int8{-3, -2, -1, 0, 1} +} + +// plugify:export NoParamReturnArrayInt16 +func NoParamReturnArrayInt16() []int16 { + fmt.Println("Go: NoParamReturnArrayInt16") + return []int16{-4, -3, -2, -1, 0, 1} +} + +// plugify:export NoParamReturnArrayInt32 +func NoParamReturnArrayInt32() []int32 { + fmt.Println("Go: NoParamReturnArrayInt32") + return []int32{-5, -4, -3, -2, -1, 0, 1} +} + +// plugify:export NoParamReturnArrayInt64 +func NoParamReturnArrayInt64() []int64 { + fmt.Println("Go: NoParamReturnArrayInt64") + return []int64{-6, -5, -4, -3, -2, -1, 0, 1} +} + +// plugify:export NoParamReturnArrayUInt8 +func NoParamReturnArrayUInt8() []uint8 { + fmt.Println("Go: NoParamReturnArrayUInt8") + return []uint8{0, 1, 2, 3, 4, 5, 6, 7, 8} +} + +// plugify:export NoParamReturnArrayUInt16 +func NoParamReturnArrayUInt16() []uint16 { + fmt.Println("Go: NoParamReturnArrayUInt16") + return []uint16{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} +} + +// plugify:export NoParamReturnArrayUInt32 +func NoParamReturnArrayUInt32() []uint32 { + fmt.Println("Go: NoParamReturnArrayUInt32") + return []uint32{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10} +} + +// plugify:export NoParamReturnArrayUInt64 +func NoParamReturnArrayUInt64() []uint64 { + fmt.Println("Go: NoParamReturnArrayUInt64") + return []uint64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11} +} + +// plugify:export NoParamReturnArrayPointer +func NoParamReturnArrayPointer() []uintptr { + fmt.Println("Go: NoParamReturnArrayPointer") + return []uintptr{0, 1, 2, 3} +} + +// plugify:export NoParamReturnArrayFloat +func NoParamReturnArrayFloat() []float32 { + fmt.Println("Go: NoParamReturnArrayFloat") + return []float32{-12.34, 0.0, 12.34} +} + +// plugify:export NoParamReturnArrayDouble +func NoParamReturnArrayDouble() []float64 { + fmt.Println("Go: NoParamReturnArrayDouble") + return []float64{-12.345, 0.0, 12.345} +} + +// plugify:export NoParamReturnArrayString +func NoParamReturnArrayString() []string { + fmt.Println("Go: NoParamReturnArrayString") + return []string{ + "1st string", "2nd string", + "3rd element string (Should be big enough to avoid small string optimization)", + } +} + +// plugify:export NoParamReturnArrayAny +func NoParamReturnArrayAny() []any { + fmt.Println("Go: NoParamReturnArrayAny") + return []any{ + 1.0, + float32(2.0), + "3rd element string (Should be big enough to avoid small string optimization)", + []string{"lolek", "and", "bolek"}, + int32(1), + } +} + +// plugify:export NoParamReturnArrayVector2 +func NoParamReturnArrayVector2() []plugify.Vector2 { + return []plugify.Vector2{ + {1.1, 2.2}, + {-3.3, 4.4}, + {5.5, -6.6}, + {7.7, 8.8}, + {0.0, 0.0}, + } +} + +// plugify:export NoParamReturnArrayVector3 +func NoParamReturnArrayVector3() []plugify.Vector3 { + return []plugify.Vector3{ + {1.1, 2.2, 3.3}, + {-4.4, 5.5, -6.6}, + {7.7, 8.8, 9.9}, + {0.0, 0.0, 0.0}, + {10.1, -11.2, 12.3}, + } +} + +// plugify:export NoParamReturnArrayVector4 +func NoParamReturnArrayVector4() []plugify.Vector4 { + return []plugify.Vector4{ + {1.1, 2.2, 3.3, 4.4}, + {-5.5, 6.6, -7.7, 8.8}, + {9.9, 0.0, -1.1, 2.2}, + {3.3, 4.4, 5.5, 6.6}, + {-7.7, -8.8, 9.9, -10.1}, + } +} + +// plugify:export NoParamReturnArrayMatrix4x4 +func NoParamReturnArrayMatrix4x4() []plugify.Matrix4x4 { + return []plugify.Matrix4x4{ + { + M: [4][4]float32{ + {1.0, 0.0, 0.0, 0.0}, + {0.0, 1.0, 0.0, 0.0}, + {0.0, 0.0, 1.0, 0.0}, + {0.0, 0.0, 0.0, 1.0}, + }, + }, + { + M: [4][4]float32{ + {2.0, 3.0, 4.0, 5.0}, + {6.0, 7.0, 8.0, 9.0}, + {10.0, 11.0, 12.0, 13.0}, + {14.0, 15.0, 16.0, 17.0}, + }, + }, + { + M: [4][4]float32{ + {-1.0, -2.0, -3.0, -4.0}, + {-5.0, -6.0, -7.0, -8.0}, + {-9.0, -10.0, -11.0, -12.0}, + {-13.0, -14.0, -15.0, -16.0}, + }, + }, + } +} + +// plugify:export NoParamReturnVector2 +func NoParamReturnVector2() plugify.Vector2 { + fmt.Println("Go: NoParamReturnVector2") + return plugify.Vector2{X: 1, Y: 2} +} + +// plugify:export NoParamReturnVector3 +func NoParamReturnVector3() plugify.Vector3 { + fmt.Println("Go: NoParamReturnVector3") + return plugify.Vector3{X: 1, Y: 2, Z: 3} +} + +// plugify:export NoParamReturnVector4 +func NoParamReturnVector4() plugify.Vector4 { + fmt.Println("Go: NoParamReturnVector4") + return plugify.Vector4{X: 1, Y: 2, Z: 3, W: 4} +} + +// plugify:export NoParamReturnMatrix4x4 +func NoParamReturnMatrix4x4() plugify.Matrix4x4 { + fmt.Println("Go: NoParamReturnMatrix4x4") + return plugify.Matrix4x4{ + M: [4][4]float32{ + {1, 2, 3, 4}, + {5, 6, 7, 8}, + {9, 10, 11, 12}, + {13, 14, 15, 16}, + }, + } +} + +// plugify:export Param1 +func Param1(a int32) { + fmt.Printf("Param1: a = %d\n", a) +} + +// plugify:export Param2 +func Param2(a int32, b float32) { + fmt.Printf("Param2: a = %d, b = %f\n", a, b) +} + +// plugify:export Param3 +func Param3(a int32, b float32, c float64) { + fmt.Printf("Param3: a = %d, b = %f, c = %f\n", a, b, c) +} + +// plugify:export Param4 +func Param4(a int32, b float32, c float64, d plugify.Vector4) { + fmt.Printf("Param4: a = %d, b = %f, c = %f, d = [%f,%f,%f,%f]\n", a, b, c, formatVector4(d)) +} + +// plugify:export Param5 +func Param5(a int32, b float32, c float64, d plugify.Vector4, e []int64) { + fmt.Printf("Param5: a = %d, b = %f, c = %f, d = [%f,%f,%f,%f], e.size() = %d, e = [", a, b, c, formatVector4(d), len(e)) + for _, elem := range e { + fmt.Printf("%d, ", elem) + } + fmt.Println("]") +} + +// plugify:export Param6 +func Param6(a int32, b float32, c float64, d plugify.Vector4, e []int64, f int8) { + fmt.Printf("Param6: a = %d, b = %f, c = %f, d = [%f,%f,%f,%f], e.size() = %d, e = [", a, b, c, formatVector4(d), len(e)) + for _, elem := range e { + fmt.Printf("%d, ", elem) + } + fmt.Printf("], f = %c\n", f) +} + +// plugify:export Param7 +func Param7(a int32, b float32, c float64, d plugify.Vector4, e []int64, f int8, g string) { + fmt.Printf("Param7: a = %d, b = %f, c = %f, d = [%f,%f,%f,%f], e.size() = %d, e = [", a, b, c, formatVector4(d), len(e)) + for _, elem := range e { + fmt.Printf("%d, ", elem) + } + fmt.Printf("], f = %c, g = %s\n", f, g) +} + +// plugify:export Param8 +func Param8(a int32, b float32, c float64, d plugify.Vector4, e []int64, f int8, g string, h uint16) { + fmt.Printf("Param8: a = %d, b = %f, c = %f, d = [%f,%f,%f,%f], e.size() = %d, e = [", a, b, c, formatVector4(d), len(e)) + for _, elem := range e { + fmt.Printf("%d, ", elem) + } + fmt.Printf("], f = %c, g = %s, h = %f\n", f, g, h) +} + +// plugify:export Param9 +func Param9(a int32, b float32, c float64, d plugify.Vector4, e []int64, f int8, g string, h uint16, k int16) { + fmt.Printf("Param9: a = %d, b = %f, c = %f, d = [%f,%f,%f,%f], e.size() = %d, e = [", a, b, c, formatVector4(d), len(e)) + for _, elem := range e { + fmt.Printf("%d, ", elem) + } + fmt.Printf("], f = %c, g = %s, h = %f, k = %d\n", f, g, h, k) +} + +// plugify:export Param10 +func Param10(a int32, b float32, c float64, d plugify.Vector4, e []int64, f int8, g string, h uint16, k int16, l uintptr) { + fmt.Printf("Param10: a = %d, b = %f, c = %f, d = [%f,%f,%f,%f], e.size() = %d, e = [", a, b, c, formatVector4(d), len(e)) + for _, elem := range e { + fmt.Printf("%d, ", elem) + } + fmt.Printf("], f = %c, g = %s, h = %f, k = %d, l = %v\n", f, g, h, k, l) +} + +// plugify:export ParamRef1 +func ParamRef1(a *int32) { + *a = 42 +} + +// plugify:export ParamRef2 +func ParamRef2(a *int32, b *float32) { + *a = 10 + *b = 3.14 +} + +// plugify:export ParamRef3 +func ParamRef3(a *int32, b *float32, c *float64) { + *a = -20 + *b = 2.718 + *c = 3.14159 +} + +// plugify:export ParamRef4 +func ParamRef4(a *int32, b *float32, c *float64, d *plugify.Vector4) { + *a = 100 + *b = -5.55 + *c = 1.618 + *d = plugify.Vector4{1.0, 2.0, 3.0, 4.0} +} + +// plugify:export ParamRef5 +func ParamRef5(a *int32, b *float32, c *float64, d *plugify.Vector4, e *[]int64) { + *a = 500 + *b = -10.5 + *c = 2.71828 + *d = plugify.Vector4{-1.0, -2.0, -3.0, -4.0} + *e = []int64{-6, -5, -4, -3, -2, -1, 0, 1} +} + +// plugify:export ParamRef6 +func ParamRef6(a *int32, b *float32, c *float64, d *plugify.Vector4, e *[]int64, f *int8) { + *a = 750 + *b = 20.0 + *c = 1.23456 + *d = plugify.Vector4{10.0, 20.0, 30.0, 40.0} + *e = []int64{-6, -5, -4} + *f = 'Z' +} + +// plugify:export ParamRef7 +func ParamRef7(a *int32, b *float32, c *float64, d *plugify.Vector4, e *[]int64, f *int8, g *string) { + *a = -1000 + *b = 3.0 + *c = -1.0 + *d = plugify.Vector4{100.0, 200.0, 300.0, 400.0} + *e = []int64{-6, -5, -4, -3} + *f = 'Y' + *g = "Hello, World!" +} + +// plugify:export ParamRef8 +func ParamRef8(a *int32, b *float32, c *float64, d *plugify.Vector4, e *[]int64, f *int8, g *string, h *uint16) { + *a = 999 + *b = -7.5 + *c = 0.123456 + *d = plugify.Vector4{-100.0, -200.0, -300.0, -400.0} + *e = []int64{-6, -5, -4, -3, -2, -1} + *f = 'X' + *g = "Goodbye, World!" + *h = 'A' +} + +// plugify:export ParamRef9 +func ParamRef9(a *int32, b *float32, c *float64, d *plugify.Vector4, e *[]int64, f *int8, g *string, h *uint16, k *int16) { + *a = -1234 + *b = 123.45 + *c = -678.9 + *d = plugify.Vector4{987.65, 432.1, 123.456, 789.123} + *e = []int64{-6, -5, -4, -3, -2, -1, 0, 1, 5, 9} + *f = 'W' + *g = "Testing, 1 2 3" + *h = 'B' + *k = 42 +} + +// plugify:export ParamRef10 +func ParamRef10(a *int32, b *float32, c *float64, d *plugify.Vector4, e *[]int64, f *int8, g *string, h *uint16, k *int16, l *uintptr) { + *a = 987 + *b = -0.123 + *c = 456.789 + *d = plugify.Vector4{-123.456, 0.987, 654.321, -789.123} + *e = []int64{-6, -5, -4, -3, -2, -1, 0, 1, 5, 9, 4, -7} + *f = 'V' + *g = "Another string" + *h = 'C' + *k = -444 + *l = 0x12345678 +} + +// plugify:export ParamRefVectors +func ParamRefVectors(p1 *[]bool, p2 *[]int8, p3 *[]uint16, p4 *[]int8, p5 *[]int16, p6 *[]int32, p7 *[]int64, p8 *[]uint8, p9 *[]uint16, p10 *[]uint32, p11 *[]uint64, p12 *[]uintptr, p13 *[]float32, p14 *[]float64, p15 *[]string) { + *p1 = []bool{true} + *p2 = []int8{'a', 'b', 'c'} + *p3 = []uint16{'d', 'e', 'f'} + *p4 = []int8{-3, -2, -1, 0, 1, 2, 3} + *p5 = []int16{-4, -3, -2, -1, 0, 1, 2, 3, 4} + *p6 = []int32{-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5} + *p7 = []int64{-6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6} + *p8 = []uint8{0, 1, 2, 3, 4, 5, 6, 7} + *p9 = []uint16{0, 1, 2, 3, 4, 5, 6, 7, 8} + *p10 = []uint32{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} + *p11 = []uint64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10} + *p12 = []uintptr{0, 1, 2} + *p13 = []float32{-12.34, 0.0, 12.34} + *p14 = []float64{-12.345, 0.0, 12.345} + *p15 = []string{"1", "12", "123", "1234", "12345", "123456"} +} + +// plugify:export ParamAllPrimitives +func ParamAllPrimitives(p1 bool, p2 int8, p3 uint16, p4 int8, p5 int16, p6 int32, p7 int64, p8 uint8, p9 uint16, p10 uint32, p11 uint64, p12 uintptr, p13 float32, p14 float64) int64 { + buffer := fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v%v", p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) + fmt.Println(buffer) + return 56 +} + +// plugify:export ParamEnum +func ParamEnum(p1 Example, p2 []Example) int32 { + sum := p1 + for _, e := range p2 { + sum += e + } + return int32(sum) +} + +// plugify:export ParamEnumRef +func ParamEnumRef(p1 *Example, p2 *[]Example) int32 { + *p1 = Forth + *p2 = []Example{First, Second, Third} + sum := *p1 + for _, e := range *p2 { + sum += e + } + return int32(sum) +} + +// plugify:export ParamVariant +func ParamVariant(p1 any, p2 []any) { + buffer := fmt.Sprintf("%v%v", p1, p2) + fmt.Println(buffer) +} + +// plugify:export ParamVariantRef +func ParamVariantRef(p1 *any, p2 *[]any) { + *p1 = 'Z' + *p2 = []any{false, 6.28, []float64{1, 2, 3}, uintptr(unsafe.Pointer(nil)), 123456789} +} + +// plugify:export CallFuncVoid +func CallFuncVoid(func_ FuncVoid) { + func_() +} + +// plugify:export CallFuncBool +func CallFuncBool(func_ FuncBool) bool { + return func_() +} + +// plugify:export CallFuncChar8 +func CallFuncChar8(func_ FuncChar8) int8 { + return func_() +} + +// plugify:export CallFuncChar16 +func CallFuncChar16(func_ FuncChar16) uint16 { + return func_() +} + +// plugify:export CallFuncInt8 +func CallFuncInt8(func_ FuncInt8) int8 { + return func_() +} + +// plugify:export CallFuncInt16 +func CallFuncInt16(func_ FuncInt16) int16 { + return func_() +} + +// plugify:export CallFuncInt32 +func CallFuncInt32(func_ FuncInt32) int32 { + return func_() +} + +// plugify:export CallFuncInt64 +func CallFuncInt64(func_ FuncInt64) int64 { + return func_() +} + +// plugify:export CallFuncUInt8 +func CallFuncUInt8(func_ FuncUInt8) uint8 { + return func_() +} + +// plugify:export CallFuncUInt16 +func CallFuncUInt16(func_ FuncUInt16) uint16 { + return func_() +} + +// plugify:export CallFuncUInt32 +func CallFuncUInt32(func_ FuncUInt32) uint32 { + return func_() +} + +// plugify:export CallFuncUInt64 +func CallFuncUInt64(func_ FuncUInt64) uint64 { + return func_() +} + +// plugify:export CallFuncPtr +func CallFuncPtr(func_ FuncPtr) uintptr { + return func_() +} + +// plugify:export CallFuncFloat +func CallFuncFloat(func_ FuncFloat) float32 { + return func_() +} + +// plugify:export CallFuncDouble +func CallFuncDouble(func_ FuncDouble) float64 { + return func_() +} + +// plugify:export CallFuncFunction +func CallFuncFunction(func_ FuncFunction) uintptr { + return func_() +} + +// plugify:export CallFuncString +func CallFuncString(func_ FuncString) string { + return func_() +} + +// plugify:export CallFuncAny +func CallFuncAny(func_ FuncAny) any { + return func_() +} + +// Call functions for vector return types +// plugify:export CallFuncBoolVector +func CallFuncBoolVector(func_ FuncBoolVector) []bool { + result := func_() + return result +} + +// plugify:export CallFuncChar8Vector +func CallFuncChar8Vector(func_ FuncChar8Vector) []int8 { + result := func_() + return result +} + +// plugify:export CallFuncChar16Vector +func CallFuncChar16Vector(func_ FuncChar16Vector) []uint16 { + result := func_() + return result +} + +// plugify:export CallFuncInt8Vector +func CallFuncInt8Vector(func_ FuncInt8Vector) []int8 { + result := func_() + return result +} + +// plugify:export CallFuncInt16Vector +func CallFuncInt16Vector(func_ FuncInt16Vector) []int16 { + result := func_() + return result +} + +// plugify:export CallFuncInt32Vector +func CallFuncInt32Vector(func_ FuncInt32Vector) []int32 { + result := func_() + return result +} + +// plugify:export CallFuncInt64Vector +func CallFuncInt64Vector(func_ FuncInt64Vector) []int64 { + result := func_() + return result +} + +// plugify:export CallFuncUInt8Vector +func CallFuncUInt8Vector(func_ FuncUInt8Vector) []uint8 { + result := func_() + return result +} + +// plugify:export CallFuncUInt16Vector +func CallFuncUInt16Vector(func_ FuncUInt16Vector) []uint16 { + result := func_() + return result +} + +// plugify:export CallFuncUInt32Vector +func CallFuncUInt32Vector(func_ FuncUInt32Vector) []uint32 { + result := func_() + return result +} + +// plugify:export CallFuncUInt64Vector +func CallFuncUInt64Vector(func_ FuncUInt64Vector) []uint64 { + result := func_() + return result +} + +// plugify:export CallFuncPtrVector +func CallFuncPtrVector(func_ FuncPtrVector) []uintptr { + result := func_() + return result +} + +// plugify:export CallFuncFloatVector +func CallFuncFloatVector(func_ FuncFloatVector) []float32 { + result := func_() + return result +} + +// plugify:export CallFuncDoubleVector +func CallFuncDoubleVector(func_ FuncDoubleVector) []float64 { + result := func_() + return result +} + +// plugify:export CallFuncStringVector +func CallFuncStringVector(func_ FuncStringVector) []string { + result := func_() + return result +} + +// plugify:export CallFuncAnyVector +func CallFuncAnyVector(func_ FuncAnyVector) []any { + result := func_() + return result +} + +// plugify:export CallFuncVec2Vector +func CallFuncVec2Vector(func_ FuncVec2Vector) []plugify.Vector2 { + result := func_() + return result +} + +// plugify:export CallFuncVec3Vector +func CallFuncVec3Vector(func_ FuncVec3Vector) []plugify.Vector3 { + result := func_() + return result +} + +// plugify:export CallFuncVec4Vector +func CallFuncVec4Vector(func_ FuncVec4Vector) []plugify.Vector4 { + result := func_() + return result +} + +// plugify:export CallFuncMat4x4Vector +func CallFuncMat4x4Vector(func_ FuncMat4x4Vector) []plugify.Matrix4x4 { + result := func_() + return result +} + +// plugify:export CallFuncVec2 +func CallFuncVec2(func_ FuncVec2) plugify.Vector2 { + result := func_() + return result +} + +// plugify:export CallFuncVec3 +func CallFuncVec3(func_ FuncVec3) plugify.Vector3 { + result := func_() + return result +} + +// plugify:export CallFuncVec4 +func CallFuncVec4(func_ FuncVec4) plugify.Vector4 { + result := func_() + return result +} + +// plugify:export CallFuncMat4x4 +func CallFuncMat4x4(func_ FuncMat4x4) plugify.Matrix4x4 { + result := func_() + return result +} + +// plugify:export CallFunc1 +func CallFunc1(func_ Func1) int32 { + vec := plugify.Vector3{4.5, 5.6, 6.7} + return func_(&vec) +} + +// plugify:export CallFunc2 +func CallFunc2(func_ Func2) int8 { + f := float32(2.71) + i64 := int64(200) + return func_(f, i64) +} + +// plugify:export CallFunc3 +func CallFunc3(func_ Func3) { + ptr := uintptr(12345) + vec4 := plugify.Vector4{7.8, 8.9, 9.1, 10.2} + str := "RandomString" + func_(ptr, &vec4, str) +} + +// plugify:export CallFunc4 +func CallFunc4(func_ Func4) plugify.Vector4 { + b := false + u32 := int32(42) + ch16 := uint16('B') + mat := plugify.Matrix4x4Identity() + return func_(b, u32, ch16, &mat) +} + +// plugify:export CallFunc5 +func CallFunc5(func_ Func5) bool { + i8 := int8(10) + vec2 := plugify.Vector2{3.4, 5.6} + ptr := uintptr(67890) + d := 1.618 + vec64 := []uint64{4, 5, 6} + return func_(i8, &vec2, ptr, d, vec64) +} + +// plugify:export CallFunc6 +func CallFunc6(func_ Func6) int64 { + str := "AnotherString" + f := float32(4.56) + vecF := []float32{4.0, 5.0, 6.0} + i16 := int16(30) + vecU8 := []uint8{3, 4, 5} + ptr := uintptr(24680) + return func_(str, f, vecF, i16, vecU8, ptr) +} + +// plugify:export CallFunc7 +func CallFunc7(func_ Func7) float64 { + vecC := []int8{'X', 'Y', 'Z'} + u16 := uint16(20) + ch16 := uint16('C') + vecU32 := []uint32{4, 5, 6} + vec4 := plugify.Vector4{4.5, 5.6, 6.7, 7.8} + b := false + u64 := uint64(200) + return func_(vecC, u16, ch16, vecU32, &vec4, b, u64) +} + +// plugify:export CallFunc8 +func CallFunc8(func_ Func8) plugify.Matrix4x4 { + vec3 := plugify.Vector3{4.0, 5.0, 6.0} + vecU32 := []uint32{4, 5, 6} + i16 := int16(30) + b := false + vec4 := plugify.Vector4{4.5, 5.6, 6.7, 7.8} + vecC16 := []uint16{'D', 'E'} + ch16 := uint16('B') + i32 := int32(50) + return func_(&vec3, vecU32, i16, b, &vec4, vecC16, ch16, i32) +} + +// plugify:export CallFunc9 +func CallFunc9(func_ Func9) { + f := float32(2.71) + vec2 := plugify.Vector2{3.4, 5.6} + vecI8 := []int8{4, 5, 6} + u64 := uint64(250) + b := false + str := "Random" + vec4 := plugify.Vector4{4.5, 5.6, 6.7, 7.8} + i16 := int16(30) + ptr := uintptr(13579) + func_(f, &vec2, vecI8, u64, b, str, &vec4, i16, ptr) +} + +// plugify:export CallFunc10 +func CallFunc10(func_ Func10) uint32 { + vec4 := plugify.Vector4{5.6, 7.8, 8.9, 9.0} + mat := plugify.Matrix4x4Identity() + vecU32 := []uint32{4, 5, 6} + u64 := uint64(150) + vecC := []int8{'X', 'Y', 'Z'} + i32 := int32(60) + b := false + vec2 := plugify.Vector2{3.4, 5.6} + i64 := int64(75) + d := 2.71 + return func_(&vec4, &mat, vecU32, u64, vecC, i32, b, &vec2, i64, d) +} + +// plugify:export CallFunc11 +func CallFunc11(func_ Func11) uintptr { + vecB := []bool{false, true, false} + ch16 := uint16('C') + u8 := uint8(10) + d := 2.71 + vec3 := plugify.Vector3{4.0, 5.0, 6.0} + vecI8 := []int8{3, 4, 5} + i64 := int64(150) + u16 := uint16(20) + f := float32(2.0) + vec2 := plugify.Vector2{4.5, 6.7} + u32 := uint32(30) + return func_(vecB, ch16, u8, d, &vec3, vecI8, i64, u16, f, &vec2, u32) +} + +// plugify:export CallFunc12 +func CallFunc12(func_ Func12) bool { + ptr := uintptr(98765) + vecD := []float64{4.0, 5.0, 6.0} + u32 := uint32(30) + d := 1.41 + b := false + i32 := int32(25) + i8 := int8(10) + u64 := uint64(300) + f := float32(2.72) + vecPtr := []uintptr{2, 3, 4} + i64 := int64(200) + ch := int8('B') + return func_(ptr, vecD, u32, d, b, i32, i8, u64, f, vecPtr, i64, ch) +} + +// plugify:export CallFunc13 +func CallFunc13(func_ Func13) string { + i64 := int64(75) + vecC := []int8{'D', 'E', 'F'} + u16 := uint16(20) + f := float32(2.71) + vecB := []bool{false, true, false} + vec4 := plugify.Vector4{5.6, 7.8, 9.0, 10.1} + str := "RandomString" + i32 := int32(30) + vec3 := plugify.Vector3{4.0, 5.0, 6.0} + ptr := uintptr(13579) + vec2 := plugify.Vector2{4.5, 6.7} + vecU8 := []uint8{2, 3, 4} + i16 := int16(20) + return func_(i64, vecC, u16, f, vecB, &vec4, str, i32, &vec3, ptr, &vec2, vecU8, i16) +} + +// plugify:export CallFunc14 +func CallFunc14(func_ Func14) []string { + vecC := []int8{'D', 'E', 'F'} + vecU32 := []uint32{4, 5, 6} + mat := plugify.Matrix4x4Identity() + b := false + ch16 := uint16('B') + i32 := int32(25) + vecF := []float32{4.0, 5.0, 6.0} + u16 := uint16(30) + vecU8 := []uint8{3, 4, 5} + i8 := int8(10) + vec3 := plugify.Vector3{4.0, 5.0, 6.0} + vec4 := plugify.Vector4{5.6, 7.8, 9.0, 10.1} + d := 2.72 + ptr := uintptr(54321) + return func_(vecC, vecU32, &mat, b, ch16, i32, vecF, u16, vecU8, i8, &vec3, &vec4, d, ptr) +} + +// plugify:export CallFunc15 +func CallFunc15(func_ Func15) int16 { + vecI16 := []int16{4, 5, 6} + mat := plugify.Matrix4x4Identity() + vec4 := plugify.Vector4{7.8, 8.9, 9.0, 10.1} + ptr := uintptr(12345) + u64 := uint64(200) + vecU32 := []uint32{5, 6, 7} + b := false + f := float32(3.14) + vecC16 := []uint16{'D', 'E'} + u8 := uint8(6) + i32 := int32(25) + vec2 := plugify.Vector2{5.6, 7.8} + u16 := uint16(40) + d := 2.71 + vecU8 := []uint8{1, 3, 5} + return func_(vecI16, &mat, &vec4, ptr, u64, vecU32, b, f, vecC16, u8, i32, &vec2, u16, d, vecU8) +} + +// plugify:export CallFunc16 +func CallFunc16(func_ Func16) uintptr { + vecB := []bool{true, true, false} + i16 := int16(20) + vecI8 := []int8{2, 3, 4} + vec4 := plugify.Vector4{7.8, 8.9, 9.0, 10.1} + mat := plugify.Matrix4x4Identity() + vec2 := plugify.Vector2{5.6, 7.8} + vecU64 := []uint64{5, 6, 7} + vecC := []int8{'D', 'E', 'F'} + str := "DifferentString" + i64 := int64(300) + vecU32 := []uint32{6, 7, 8} + vec3 := plugify.Vector3{5.0, 6.0, 7.0} + f := float32(3.14) + d := 2.718 + i8 := int8(6) + u16 := uint16(30) + return func_(vecB, i16, vecI8, &vec4, &mat, &vec2, vecU64, vecC, str, i64, vecU32, &vec3, f, d, i8, u16) +} + +// Implement the functions +// plugify:export CallFunc17 +func CallFunc17(func_ Func17) string { + i32 := int32(42) + func_(&i32) + return fmt.Sprintf("%d", i32) +} + +// plugify:export CallFunc18 +func CallFunc18(func_ Func18) string { + i8 := int8(9) + i16 := int16(25) + ret := func_(&i8, &i16) + return fmt.Sprintf("%s|%d|%d", formatVector2(ret), i8, i16) +} + +// plugify:export CallFunc19 +func CallFunc19(func_ Func19) string { + u32 := uint32(75) + vec3 := plugify.Vector3{4.0, 5.0, 6.0} + vecU32 := []uint32{4, 5, 6} + func_(&u32, &vec3, &vecU32) + return fmt.Sprintf("%d|%v|%v", u32, formatVector3(vec3), formatArray(vecU32)) +} + +// plugify:export CallFunc20 +func CallFunc20(func_ Func20) string { + ch16 := uint16('Z') + vec4 := plugify.Vector4{5.0, 6.0, 7.0, 8.0} + vecU64 := []uint64{4, 5, 6} + ch := int8('X') + ret := func_(&ch16, &vec4, &vecU64, &ch) + return fmt.Sprintf("%d|%d|%v|%v|%c", ret, ch16, formatVector4(vec4), formatArray(vecU64), ch) +} + +// plugify:export CallFunc21 +func CallFunc21(func_ Func21) string { + mat := plugify.Matrix4x4{} + vecI32 := []int32{4, 5, 6} + vec2 := plugify.Vector2{3.0, 4.0} + b := false + d := 6.28 + ret := func_(&mat, &vecI32, &vec2, &b, &d) + return fmt.Sprintf("%v|%v|%v|%v|%t|%v", formatFlt32(ret), formatMatrix4x4(mat), formatArray(vecI32), formatVector2(vec2), b, formatFlt64(d)) +} + +// plugify:export CallFunc22 +func CallFunc22(func_ Func22) string { + ptr := uintptr(1) + u32 := uint32(20) + vecD := []float64{4.0, 5.0, 6.0} + i16 := int16(15) + str := "Updated Test" + vec4 := plugify.Vector4{5.0, 6.0, 7.0, 8.0} + ret := func_(&ptr, &u32, &vecD, &i16, &str, &vec4) + return fmt.Sprintf("%d|0x%x|%d|%v|%d|%v|%v", ret, ptr, u32, formatArrayFmt(vecD, formatFlt64), i16, str, formatVector4(vec4)) +} + +// plugify:export CallFunc23 +func CallFunc23(func_ Func23) string { + u64 := uint64(200) + vec2 := plugify.Vector2{3.0, 4.0} + vecI16 := []int16{4, 5, 6} + ch16 := uint16('Y') + f := float32(2.34) + i8 := int8(10) + vecU8 := []uint8{3, 4, 5} + func_(&u64, &vec2, &vecI16, &ch16, &f, &i8, &vecU8) + return fmt.Sprintf("%d|%v|%v|%d|%v|%d|%v", u64, formatVector2(vec2), formatArray(vecI16), ch16, formatFlt32(f), i8, formatArray(vecU8)) +} + +// plugify:export CallFunc24 +func CallFunc24(func_ Func24) string { + vecC := []int8{'D', 'E', 'F'} + i64 := int64(100) + vecU8 := []uint8{3, 4, 5} + vec4 := plugify.Vector4{5.0, 6.0, 7.0, 8.0} + u64 := uint64(200) + vecPtr := []uintptr{3, 4, 5} + d := 6.28 + vecV2 := []uintptr{4, 5, 6, 7} + ret := func_(&vecC, &i64, &vecU8, &vec4, &u64, &vecPtr, &d, &vecV2) + return fmt.Sprintf("%v|%v|%d|%v|%v|%d|%v|%v|%v", formatMatrix4x4(ret), formatArrayFmt(vecC, formatChr), i64, formatArray(vecU8), formatVector4(vec4), u64, formatArrayFmt(vecPtr, formatPtr), formatFlt64(d), formatArrayFmt(vecV2, formatPtr)) +} + +// plugify:export CallFunc25 +func CallFunc25(func_ Func25) string { + i32 := int32(50) + vecPtr := []uintptr{3, 4, 5} + b := false + u8 := uint8(10) + str := "Updated Test String" + vec3 := plugify.Vector3{4.0, 5.0, 6.0} + i64 := int64(100) + vec4 := plugify.Vector4{5.0, 6.0, 7.0, 8.0} + u16 := uint16(20) + ret := func_(&i32, &vecPtr, &b, &u8, &str, &vec3, &i64, &vec4, &u16) + return fmt.Sprintf("%v|%d|%v|%t|%d|%v|%v|%d|%v|%d", formatFlt64(ret), i32, formatArrayFmt(vecPtr, formatPtr), b, u8, str, formatVector3(vec3), i64, formatVector4(vec4), u16) +} + +// plugify:export CallFunc26 +func CallFunc26(func_ Func26) string { + ch16 := uint16('B') + vec2 := plugify.Vector2{3.0, 4.0} + mat := plugify.Matrix4x4{} + vecF := []float32{4.0, 5.0, 6.0} + i16 := int16(20) + u64 := uint64(200) + u32 := uint32(20) + vecU16 := []uint16{3, 4, 5} + ptr := uintptr(0xDEADBEAFDEADBEAF) + b := false + ret := func_(&ch16, &vec2, &mat, &vecF, &i16, &u64, &u32, &vecU16, &ptr, &b) + return fmt.Sprintf("%c|%d|%v|%v|%v|%d|%d|%v|0x%x|%t", ret, ch16, formatVector2(vec2), formatMatrix4x4(mat), formatArrayFmt(vecF, formatFlt32), u64, u32, formatArray(vecU16), ptr, b) +} + +// plugify:export CallFunc27 +func CallFunc27(func_ Func27) string { + f := float32(2.56) + vec3 := plugify.Vector3{4.0, 5.0, 6.0} + ptr := uintptr(0) + vec2 := plugify.Vector2{3.0, 4.0} + vecI16 := []int16{4, 5, 6} + mat := plugify.Matrix4x4{} + b := false + vec4 := plugify.Vector4{5.0, 6.0, 7.0, 8.0} + i8 := int8(10) + i32 := int32(40) + vecU8 := []uint8{3, 4, 5} + ret := func_(&f, &vec3, &ptr, &vec2, &vecI16, &mat, &b, &vec4, &i8, &i32, &vecU8) + return fmt.Sprintf("%d|%v|%v|0x%x|%v|%v|%v|%t|%v|%d|%d|%v", ret, formatFlt32(f), formatVector3(vec3), ptr, formatVector2(vec2), formatArray(vecI16), formatMatrix4x4(mat), b, formatVector4(vec4), i8, i32, formatArray(vecU8)) +} + +// plugify:export CallFunc28 +func CallFunc28(func_ Func28) string { + ptr := uintptr(1) + u16 := uint16(20) + vecU32 := []uint32{4, 5, 6} + mat := plugify.Matrix4x4{} + f := float32(2.71) + vec4 := plugify.Vector4{5.0, 6.0, 7.0, 8.0} + str := "New example string" + vecU64 := []uint64{400, 500, 600} + i64 := int64(987654321) + b := false + vec3 := plugify.Vector3{4.0, 5.0, 6.0} + vecF := []float32{4.0, 5.0, 6.0} + ret := func_(&ptr, &u16, &vecU32, &mat, &f, &vec4, &str, &vecU64, &i64, &b, &vec3, &vecF) + return fmt.Sprintf("%v|0x%x|%d|%v|%v|%v|%v|%v|%v|%d|%t|%v|%v", ret, ptr, u16, formatArray(vecU32), formatMatrix4x4(mat), formatFlt32(f), formatVector4(vec4), str, formatArray(vecU64), i64, b, formatVector3(vec3), formatArrayFmt(vecF, formatFlt32)) +} + +// plugify:export CallFunc29 +func CallFunc29(func_ Func29) string { + vec4 := plugify.Vector4{2.0, 3.0, 4.0, 5.0} + i32 := int32(99) + vecI8 := []int8{4, 5, 6} + d := float64(2.71) + b := false + i8 := int8(10) + vecU16 := []uint16{4, 5, 6} + f := float32(3.21) + str := "Yet another example string" + mat := plugify.Matrix4x4{} + u64 := uint64(200) + vec3 := plugify.Vector3{5.0, 6.0, 7.0} + vecI64 := []int64{2000, 3000, 4000} + ret := func_(&vec4, &i32, &vecI8, &d, &b, &i8, &vecU16, &f, &str, &mat, &u64, &vec3, &vecI64) + return fmt.Sprintf("%v|%v|%d|%v|%v|%t|%d|%v|%v|%s|%v|%d|%v|%v", formatArrayFmt(ret, formatStr), formatVector4(vec4), i32, formatArray(vecI8), formatFlt64(d), b, i8, formatArray(vecU16), formatFlt32(f), str, formatMatrix4x4(mat), u64, formatVector3(vec3), formatArray(vecI64)) +} + +// plugify:export CallFunc30 +func CallFunc30(func_ Func30) string { + ptr := uintptr(1) + vec4 := plugify.Vector4{2.0, 3.0, 4.0, 5.0} + i64 := int64(987654321) + vecU32 := []uint32{4, 5, 6} + b := false + str := "Updated String for Func30" + vec3 := plugify.Vector3{5.0, 6.0, 7.0} + vecU8 := []uint8{1, 2, 3} + f := float32(5.67) + vec2 := plugify.Vector2{3.0, 4.0} + mat := plugify.Matrix4x4{} + i8 := int8(10) + vecF := []float32{4.0, 5.0, 6.0} + d := float64(8.90) + ret := func_(&ptr, &vec4, &i64, &vecU32, &b, &str, &vec3, &vecU8, &f, &vec2, &mat, &i8, &vecF, &d) + return fmt.Sprintf("%d|0x%x|%v|%d|%v|%t|%s|%v|%v|%v|%v|%v|%d|%v|%v", ret, ptr, formatVector4(vec4), i64, formatArray(vecU32), b, str, formatVector3(vec3), formatArray(vecU8), formatFlt32(f), formatVector2(vec2), formatMatrix4x4(mat), i8, formatArrayFmt(vecF, formatFlt32), formatFlt64(d)) +} + +// plugify:export CallFunc31 +func CallFunc31(func_ Func31) string { + ch := int8('B') + u32 := uint32(200) + vecU64 := []uint64{4, 5, 6} + vec4 := plugify.Vector4{2.0, 3.0, 4.0, 5.0} + str := "Updated String for Func31" + b := true + i64 := int64(987654321) + vec2 := plugify.Vector2{3.0, 4.0} + i8 := int8(10) + u16 := uint16(20) + vecI16 := []int16{4, 5, 6} + mat := plugify.Matrix4x4{} + vec3 := plugify.Vector3{4.0, 5.0, 6.0} + f := float32(5.67) + vecD := []float64{4.0, 5.0, 6.0} + ret := func_(&ch, &u32, &vecU64, &vec4, &str, &b, &i64, &vec2, &i8, &u16, &vecI16, &mat, &vec3, &f, &vecD) + return fmt.Sprintf("%v|%c|%d|%v|%v|%s|%t|%d|%v|%d|%d|%v|%v|%v|%v|%v", formatVector3(ret), ch, u32, formatArray(vecU64), formatVector4(vec4), str, b, i64, formatVector2(vec2), i8, u16, formatArray(vecI16), formatMatrix4x4(mat), formatVector3(vec3), formatFlt32(f), formatArrayFmt(vecD, formatFlt64)) +} + +// plugify:export CallFunc32 +func CallFunc32(func_ Func32) string { + i32 := int32(30) + u16 := uint16(20) + vecI8 := []int8{4, 5, 6} + vec4 := plugify.Vector4{2.0, 3.0, 4.0, 5.0} + ptr := uintptr(1) + vecU32 := []uint32{4, 5, 6} + mat := plugify.Matrix4x4{} + u64 := uint64(200) + str := "Updated String for Func32" + i64 := int64(987654321) + vec2 := plugify.Vector2{3.0, 4.0} + vecI8_2 := []int8{7, 8, 9} + b := false + vec3 := plugify.Vector3{4.0, 5.0, 6.0} + u8 := uint8(128) + vecC16 := []uint16{'D', 'E', 'F'} + + func_(&i32, &u16, &vecI8, &vec4, &ptr, &vecU32, &mat, &u64, &str, &i64, &vec2, &vecI8_2, &b, &vec3, &u8, &vecC16) + return fmt.Sprintf("%d|%d|%v|%v|0x%x|%v|%v|%d|%s|%d|%v|%v|%t|%v|%d|%v", i32, u16, formatArray(vecI8), formatVector4(vec4), ptr, formatArray(vecU32), formatMatrix4x4(mat), u64, str, i64, formatVector2(vec2), formatArray(vecI8_2), b, formatVector3(vec3), u8, formatArray(vecC16)) +} + +// plugify:export CallFunc33 +func CallFunc33(func_ Func33) string { + var variant any + variant = int32(30) + func_(&variant) + return fmt.Sprintf("%v", variant) +} + +// plugify:export CallFuncEnum +func CallFuncEnum(func_ FuncEnum) string { + p1 := Forth + p2 := []Example{} + ret := func_(p1, &p2) + retStr := fmt.Sprintf("%v|%v", formatArray(ret), formatArray(p2)) + return retStr +} + +// +// Reverse staff +// Define the function implementations +// + +// plugify:export ReverseNoParamReturnVoid +func ReverseNoParamReturnVoid() string { + cross_call_master.NoParamReturnVoidCallback() + return "" +} + +// plugify:export ReverseNoParamReturnBool +func ReverseNoParamReturnBool() string { + result := cross_call_master.NoParamReturnBoolCallback() + return formatBool(result) +} + +// plugify:export ReverseNoParamReturnChar8 +func ReverseNoParamReturnChar8() string { + result := cross_call_master.NoParamReturnChar8Callback() + return fmt.Sprintf("%c", result) +} + +// plugify:export ReverseNoParamReturnChar16 +func ReverseNoParamReturnChar16() string { + result := cross_call_master.NoParamReturnChar16Callback() + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseNoParamReturnInt8 +func ReverseNoParamReturnInt8() string { + result := cross_call_master.NoParamReturnInt8Callback() + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseNoParamReturnInt16 +func ReverseNoParamReturnInt16() string { + result := cross_call_master.NoParamReturnInt16Callback() + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseNoParamReturnInt32 +func ReverseNoParamReturnInt32() string { + result := cross_call_master.NoParamReturnInt32Callback() + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseNoParamReturnInt64 +func ReverseNoParamReturnInt64() string { + result := cross_call_master.NoParamReturnInt64Callback() + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseNoParamReturnUInt8 +func ReverseNoParamReturnUInt8() string { + result := cross_call_master.NoParamReturnUInt8Callback() + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseNoParamReturnUInt16 +func ReverseNoParamReturnUInt16() string { + result := cross_call_master.NoParamReturnUInt16Callback() + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseNoParamReturnUInt32 +func ReverseNoParamReturnUInt32() string { + result := cross_call_master.NoParamReturnUInt32Callback() + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseNoParamReturnUInt64 +func ReverseNoParamReturnUInt64() string { + result := cross_call_master.NoParamReturnUInt64Callback() + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseNoParamReturnPointer +func ReverseNoParamReturnPointer() string { + result := cross_call_master.NoParamReturnPointerCallback() + return fmt.Sprintf("0x%x", result) +} + +// plugify:export ReverseNoParamReturnFloat +func ReverseNoParamReturnFloat() string { + result := cross_call_master.NoParamReturnFloatCallback() + return fmt.Sprintf("%v", formatFlt32(result)) +} + +// plugify:export ReverseNoParamReturnDouble +func ReverseNoParamReturnDouble() string { + result := cross_call_master.NoParamReturnDoubleCallback() + return fmt.Sprintf("%v", formatFlt64(result)) +} + +// plugify:export ReverseNoParamReturnFunction +func ReverseNoParamReturnFunction() string { + result := cross_call_master.NoParamReturnFunctionCallback() + return fmt.Sprintf("%d", result()) +} + +// plugify:export ReverseNoParamReturnString +func ReverseNoParamReturnString() string { + result := cross_call_master.NoParamReturnStringCallback() + return result +} + +// plugify:export ReverseNoParamReturnAny +func ReverseNoParamReturnAny() string { + result := cross_call_master.NoParamReturnAnyCallback() + return fmt.Sprintf("%v", result) +} + +// plugify:export ReverseNoParamReturnArrayBool +func ReverseNoParamReturnArrayBool() string { + result := cross_call_master.NoParamReturnArrayBoolCallback() + return formatArrayFmt(result, formatBool) +} + +// plugify:export ReverseNoParamReturnArrayChar8 +func ReverseNoParamReturnArrayChar8() string { + result := cross_call_master.NoParamReturnArrayChar8Callback() + return formatArrayFmt(result, formatChr) +} + +// plugify:export ReverseNoParamReturnArrayChar16 +func ReverseNoParamReturnArrayChar16() string { + result := cross_call_master.NoParamReturnArrayChar16Callback() + return formatArray(result) +} + +// plugify:export ReverseNoParamReturnArrayInt8 +func ReverseNoParamReturnArrayInt8() string { + result := cross_call_master.NoParamReturnArrayInt8Callback() + return formatArray(result) +} + +// plugify:export ReverseNoParamReturnArrayInt16 +func ReverseNoParamReturnArrayInt16() string { + result := cross_call_master.NoParamReturnArrayInt16Callback() + return formatArray(result) +} + +// plugify:export ReverseNoParamReturnArrayInt32 +func ReverseNoParamReturnArrayInt32() string { + result := cross_call_master.NoParamReturnArrayInt32Callback() + return formatArray(result) +} + +// plugify:export ReverseNoParamReturnArrayInt64 +func ReverseNoParamReturnArrayInt64() string { + result := cross_call_master.NoParamReturnArrayInt64Callback() + return formatArray(result) +} + +// plugify:export ReverseNoParamReturnArrayUInt8 +func ReverseNoParamReturnArrayUInt8() string { + result := cross_call_master.NoParamReturnArrayUInt8Callback() + return formatArray(result) +} + +// plugify:export ReverseNoParamReturnArrayUInt16 +func ReverseNoParamReturnArrayUInt16() string { + result := cross_call_master.NoParamReturnArrayUInt16Callback() + return formatArray(result) +} + +// plugify:export ReverseNoParamReturnArrayUInt32 +func ReverseNoParamReturnArrayUInt32() string { + result := cross_call_master.NoParamReturnArrayUInt32Callback() + return formatArray(result) +} + +// plugify:export ReverseNoParamReturnArrayUInt64 +func ReverseNoParamReturnArrayUInt64() string { + result := cross_call_master.NoParamReturnArrayUInt64Callback() + return formatArray(result) +} + +// plugify:export ReverseNoParamReturnArrayPointer +func ReverseNoParamReturnArrayPointer() string { + result := cross_call_master.NoParamReturnArrayPointerCallback() + return formatArrayFmt(result, formatPtr) +} + +// plugify:export ReverseNoParamReturnArrayFloat +func ReverseNoParamReturnArrayFloat() string { + result := cross_call_master.NoParamReturnArrayFloatCallback() + return formatArrayFmt(result, formatFlt32) +} + +// plugify:export ReverseNoParamReturnArrayDouble +func ReverseNoParamReturnArrayDouble() string { + result := cross_call_master.NoParamReturnArrayDoubleCallback() + return formatArrayFmt(result, formatFlt64) +} + +// plugify:export ReverseNoParamReturnArrayString +func ReverseNoParamReturnArrayString() string { + result := cross_call_master.NoParamReturnArrayStringCallback() + return formatArrayFmt(result, formatStr) +} + +// plugify:export ReverseNoParamReturnArrayAny +func ReverseNoParamReturnArrayAny() string { + result := cross_call_master.NoParamReturnArrayAnyCallback() + return formatArrayFmt(result, formatAny) +} + +// plugify:export ReverseNoParamReturnVector2 +func ReverseNoParamReturnVector2() string { + result := cross_call_master.NoParamReturnVector2Callback() + return formatVector2(result) +} + +// plugify:export ReverseNoParamReturnVector3 +func ReverseNoParamReturnVector3() string { + result := cross_call_master.NoParamReturnVector3Callback() + return formatVector3(result) +} + +// plugify:export ReverseNoParamReturnVector4 +func ReverseNoParamReturnVector4() string { + result := cross_call_master.NoParamReturnVector4Callback() + return formatVector4(result) +} + +// plugify:export ReverseNoParamReturnMatrix4x4 +func ReverseNoParamReturnMatrix4x4() string { + result := cross_call_master.NoParamReturnMatrix4x4Callback() + return formatMatrix4x4(result) +} + +// plugify:export ReverseParam1 +func ReverseParam1() string { + cross_call_master.Param1Callback(999) + return "" +} + +// plugify:export ReverseParam2 +func ReverseParam2() string { + cross_call_master.Param2Callback(888, 9.9) + return "" +} + +// plugify:export ReverseParam3 +func ReverseParam3() string { + cross_call_master.Param3Callback(777, 8.8, 9.8765) + return "" +} + +// plugify:export ReverseParam4 +func ReverseParam4() string { + cross_call_master.Param4Callback(666, 7.7, 8.7659, plugify.Vector4{100.1, 200.2, 300.3, 400.4}) + return "" +} + +// plugify:export ReverseParam5 +func ReverseParam5() string { + cross_call_master.Param5Callback(555, 6.6, 7.6598, plugify.Vector4{-105.1, -205.2, -305.3, -405.4}, []int64{}) + return "" +} + +// plugify:export ReverseParam6 +func ReverseParam6() string { + cross_call_master.Param6Callback(444, 5.5, 6.5987, plugify.Vector4{110.1, 210.2, 310.3, 410.4}, []int64{90000, -100, 20000}, 'A') + return "" +} + +// plugify:export ReverseParam7 +func ReverseParam7() string { + cross_call_master.Param7Callback(333, 4.4, 5.9876, plugify.Vector4{-115.1, -215.2, -315.3, -415.4}, []int64{800000, 30000, -4000000}, 'B', "red gold") + return "" +} + +// plugify:export ReverseParam8 +func ReverseParam8() string { + cross_call_master.Param8Callback(222, 3.3, 1.2345, plugify.Vector4{120.1, 220.2, 320.3, 420.4}, []int64{7000000, 5000000, -600000000}, 'C', "blue ice", 'Z') + return "" +} + +// plugify:export ReverseParam9 +func ReverseParam9() string { + cross_call_master.Param9Callback(111, 2.2, 5.1234, plugify.Vector4{-125.1, -225.2, -325.3, -425.4}, []int64{60000000, -700000000, 80000000000}, 'D', "pink metal", 'Y', -100) + return "" +} + +// plugify:export ReverseParam10 +func ReverseParam10() string { + cross_call_master.Param10Callback(1234, 1.1, 4.5123, plugify.Vector4{130.1, 230.2, 330.3, 430.4}, []int64{500000000, 90000000000, 1000000000000}, 'E', "green wood", 'X', -200, 0xabeba) + return "" +} + +// plugify:export ReverseParamRef1 +func ReverseParamRef1() string { + a := int32(0) + cross_call_master.ParamRef1Callback(&a) + return strconv.Itoa(int(a)) +} + +// plugify:export ReverseParamRef2 +func ReverseParamRef2() string { + a, b := int32(0), float32(0) + cross_call_master.ParamRef2Callback(&a, &b) + return fmt.Sprintf("%d|%.1f", a, b) +} + +// plugify:export ReverseParamRef3 +func ReverseParamRef3() string { + a, b, c := int32(0), float32(0), float64(0) + cross_call_master.ParamRef3Callback(&a, &b, &c) + return fmt.Sprintf("%d|%.1f|%.5f", a, b, c) +} + +// plugify:export ReverseParamRef4 +func ReverseParamRef4() string { + a, b, c := int32(0), float32(0), float64(0) + d := plugify.Vector4{} + cross_call_master.ParamRef4Callback(&a, &b, &c, &d) + return fmt.Sprintf("%d|%.1f|%.5f|%v", a, b, c, formatVector4(d)) +} + +// plugify:export ReverseParamRef5 +func ReverseParamRef5() string { + a, b, c := int32(0), float32(0), float64(0) + d := plugify.Vector4{} + e := []int64{} + cross_call_master.ParamRef5Callback(&a, &b, &c, &d, &e) + return fmt.Sprintf("%d|%.1f|%.5f|%v|%s", a, b, c, formatVector4(d), formatArray(e)) +} + +// plugify:export ReverseParamRef6 +func ReverseParamRef6() string { + a, b, c := int32(0), float32(0), float64(0) + d := plugify.Vector4{} + e := []int64{} + f := int8(0) + cross_call_master.ParamRef6Callback(&a, &b, &c, &d, &e, &f) + return fmt.Sprintf("%d|%.1f|%.5f|%v|%s|%d", a, b, c, formatVector4(d), formatArray(e), f) +} + +// plugify:export ReverseParamRef7 +func ReverseParamRef7() string { + a, b, c := int32(0), float32(0), float64(0) + d := plugify.Vector4{} + e := []int64{} + f := int8(0) + g := "" + cross_call_master.ParamRef7Callback(&a, &b, &c, &d, &e, &f, &g) + return fmt.Sprintf("%d|%.1f|%.5f|%v|%s|%d|%s", a, b, c, formatVector4(d), formatArray(e), f, g) +} + +// plugify:export ReverseParamRef8 +func ReverseParamRef8() string { + a, b, c := int32(0), float32(0), float64(0) + d := plugify.Vector4{} + e := []int64{} + f := int8(0) + g := "" + h := uint16(0) + cross_call_master.ParamRef8Callback(&a, &b, &c, &d, &e, &f, &g, &h) + return fmt.Sprintf("%d|%.1f|%.5f|%v|%s|%d|%s|%d", a, b, c, formatVector4(d), formatArray(e), f, g, h) +} + +// plugify:export ReverseParamRef9 +func ReverseParamRef9() string { + a, b, c := int32(0), float32(0), float64(0) + d := plugify.Vector4{} + e := []int64{} + f := int8(0) + g := "" + h := uint16(0) + k := int16(0) + cross_call_master.ParamRef9Callback(&a, &b, &c, &d, &e, &f, &g, &h, &k) + return fmt.Sprintf("%d|%.1f|%.5f|%v|%s|%d|%s|%d|%d", a, b, c, formatVector4(d), formatArray(e), f, g, h, k) +} + +// plugify:export ReverseParamRef10 +func ReverseParamRef10() string { + a, b, c := int32(0), float32(0), float64(0) + d := plugify.Vector4{} + e := []int64{} + f := int8(0) + g := "" + h := uint16(0) + k := int16(0) + l := uintptr(0) + cross_call_master.ParamRef10Callback(&a, &b, &c, &d, &e, &f, &g, &h, &k, &l) + return fmt.Sprintf("%d|%.1f|%.5f|%v|%s|%d|%s|%d|%d|0x%x", a, b, c, formatVector4(d), formatArray(e), f, g, h, k, l) +} + +func formatBool(b bool) string { + if b { + return "true" + } + return "false" +} + +func formatPtr(p uintptr) string { + return fmt.Sprintf("0x%x", p) +} + +func formatChr(c int8) string { + return fmt.Sprintf("%c", c) +} + +func formatStr(s string) string { + return fmt.Sprintf("'%s'", s) +} + +func formatFlt32(d float32) string { + s := fmt.Sprintf("%.3f", d) + s = strings.TrimRight(s, "0") + s = strings.TrimRight(s, ".") + return s +} + +func formatFlt64(d float64) string { + s := fmt.Sprintf("%.6f", d) + s = strings.TrimRight(s, "0") + s = strings.TrimRight(s, ".") + return s +} + +func formatAny(a any) string { + return fmt.Sprintf("%v", a) +} + +func formatVector2(t plugify.Vector2) string { + return fmt.Sprintf("{%s, %s}", formatFlt32(t.X), formatFlt32(t.Y)) +} + +func formatVector3(t plugify.Vector3) string { + return fmt.Sprintf("{%s, %s, %s}", formatFlt32(t.X), formatFlt32(t.Y), formatFlt32(t.Z)) +} + +func formatVector4(t plugify.Vector4) string { + return fmt.Sprintf("{%s, %s, %s, %s}", formatFlt32(t.X), formatFlt32(t.Y), formatFlt32(t.Z), formatFlt32(t.W)) +} + +func formatMatrix4x4(t plugify.Matrix4x4) string { + formattedRow1 := fmt.Sprintf("{%s, %s, %s, %s}", formatFlt32(t.M[0][0]), formatFlt32(t.M[0][1]), formatFlt32(t.M[0][2]), formatFlt32(t.M[0][3])) + formattedRow2 := fmt.Sprintf("{%s, %s, %s, %s}", formatFlt32(t.M[1][0]), formatFlt32(t.M[1][1]), formatFlt32(t.M[1][2]), formatFlt32(t.M[1][3])) + formattedRow3 := fmt.Sprintf("{%s, %s, %s, %s}", formatFlt32(t.M[2][0]), formatFlt32(t.M[2][1]), formatFlt32(t.M[2][2]), formatFlt32(t.M[2][3])) + formattedRow4 := fmt.Sprintf("{%s, %s, %s, %s}", formatFlt32(t.M[3][0]), formatFlt32(t.M[3][1]), formatFlt32(t.M[3][2]), formatFlt32(t.M[3][3])) + return fmt.Sprintf("{%s, %s, %s, %s}", formattedRow1, formattedRow2, formattedRow3, formattedRow4) +} + +func formatArray[T any](arr []T) string { + if len(arr) == 0 { + return "{}" + } + + str := "{" + for _, v := range arr { + str += fmt.Sprintf("%v, ", v) + } + if len(str) > 0 { + str = str[:len(str)-2] + "}" + } + return str +} + +func formatArrayFmt[T any](arr []T, format func(T) string) string { + if len(arr) == 0 { + return "{}" + } + + str := "{" + for _, v := range arr { + str += fmt.Sprintf("%s, ", format(v)) + } + if len(str) > 0 { + str = str[:len(str)-2] + "}" + } + return str +} + +// plugify:export ReverseParamRefVectors +func ReverseParamRefVectors() string { + p1 := []bool{} + p2 := []int8{} + p3 := []uint16{} + p4 := []int8{} + p5 := []int16{} + p6 := []int32{} + p7 := []int64{} + p8 := []uint8{} + p9 := []uint16{} + p10 := []uint32{} + p11 := []uint64{} + p12 := []uintptr{} + p13 := []float32{} + p14 := []float64{} + p15 := []string{} + + cross_call_master.ParamRefVectorsCallback(&p1, &p2, &p3, &p4, &p5, &p6, &p7, &p8, &p9, &p10, &p11, &p12, &p13, &p14, &p15) + + p1Formatted := formatArray(p1) + p2Formatted := formatArrayFmt(p2, formatChr) + p3Formatted := formatArray(p3) + p4Formatted := formatArray(p4) + p5Formatted := formatArray(p5) + p6Formatted := formatArray(p6) + p7Formatted := formatArray(p7) + p8Formatted := formatArray(p8) + p9Formatted := formatArray(p9) + p10Formatted := formatArray(p10) + p11Formatted := formatArray(p11) + p12Formatted := formatArrayFmt(p12, formatPtr) + p13Formatted := formatArray(p13) + p14Formatted := formatArray(p14) + p15Formatted := formatArrayFmt(p15, formatStr) + + return fmt.Sprintf("%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s", + p1Formatted, p2Formatted, p3Formatted, p4Formatted, p5Formatted, p6Formatted, p7Formatted, + p8Formatted, p9Formatted, p10Formatted, p11Formatted, p12Formatted, p13Formatted, p14Formatted, + p15Formatted) +} + +// plugify:export ReverseParamAllPrimitives +func ReverseParamAllPrimitives() string { + result := cross_call_master.ParamAllPrimitivesCallback( + true, // bool + '%', // char8 + '☢', // char16 + -1, // int8 + -1000, // int16 + -1000000, // int32 + -1000000000000, // int64 + 200, // uint8 + 50000, // uint16 + 3000000000, // uint32 + 9999999999, // uint64 + 0xfedcbaabcdef, // uintptr (used for pointer simulation) + 0.001, // float32 + 987654.456789, // float64 + ) + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseParamEnum +func ReverseParamEnum() string { + p1 := cross_call_master.Example_Forth + p2 := []cross_call_master.Example{cross_call_master.Example_First, cross_call_master.Example_Second, cross_call_master.Example_Third} + result := cross_call_master.ParamEnumCallback(p1, p2) + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseParamEnumRef +func ReverseParamEnumRef() string { + p1 := cross_call_master.Example_First + p2 := []cross_call_master.Example{cross_call_master.Example_First, cross_call_master.Example_First, cross_call_master.Example_Second} + result := cross_call_master.ParamEnumRefCallback(&p1, &p2) + return fmt.Sprintf("%d|%d|%s", result, p1, formatArray(p2)) +} + +// plugify:export ReverseParamVariant +func ReverseParamVariant() string { + p1 := "my custom string with enough chars" + p2 := []any{'X', '☢', -1, -1000, -1000000, -1000000000000, 200, 50000, 3000000000, 9999999999, 0xfedcbaabcdef, 0.001, 987654.456789} + cross_call_master.ParamVariantCallback(p1, p2) + return fmt.Sprintf("%s|%v", p1, p2) +} + +// plugify:export ReverseParamVariantRef +func ReverseParamVariantRef() string { + var p1 any = "my custom string with enough chars" + p2 := []any{int8('X'), uint16('☢'), int32(-1), int32(-1000), int32(-1000000), int64(-1000000000000), int32(200), int32(50000), int64(3000000000), int64(9999999999), uintptr(0xfedcbaabcdef), float32(0.001), float32(987654.456789)} + cross_call_master.ParamVariantRefCallback(&p1, &p2) + return fmt.Sprintf("%s|{%v, %v, %s}", formatArray(p1.([]int32)), p2[0].(bool), formatFlt32(p2[1].(float32)), p2[2].(string)) +} + +// plugify:export ReverseCallFuncVoid +func ReverseCallFuncVoid() string { + cross_call_master.CallFuncVoidCallback(MockVoid) + return "" +} + +// plugify:export ReverseCallFuncBool +func ReverseCallFuncBool() string { + result := cross_call_master.CallFuncBoolCallback(MockBool) + return formatBool(result) +} + +// plugify:export ReverseCallFuncChar8 +func ReverseCallFuncChar8() string { + result := cross_call_master.CallFuncChar8Callback(MockChar8) + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseCallFuncChar16 +func ReverseCallFuncChar16() string { + result := cross_call_master.CallFuncChar16Callback(MockChar16) + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseCallFuncInt8 +func ReverseCallFuncInt8() string { + result := cross_call_master.CallFuncInt8Callback(MockInt8) + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseCallFuncInt16 +func ReverseCallFuncInt16() string { + result := cross_call_master.CallFuncInt16Callback(MockInt16) + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseCallFuncInt32 +func ReverseCallFuncInt32() string { + result := cross_call_master.CallFuncInt32Callback(MockInt32) + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseCallFuncInt64 +func ReverseCallFuncInt64() string { + result := cross_call_master.CallFuncInt64Callback(MockInt64) + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseCallFuncUInt8 +func ReverseCallFuncUInt8() string { + result := cross_call_master.CallFuncUInt8Callback(MockUInt8) + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseCallFuncUInt16 +func ReverseCallFuncUInt16() string { + result := cross_call_master.CallFuncUInt16Callback(MockUInt16) + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseCallFuncUInt32 +func ReverseCallFuncUInt32() string { + result := cross_call_master.CallFuncUInt32Callback(MockUInt32) + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseCallFuncUInt64 +func ReverseCallFuncUInt64() string { + result := cross_call_master.CallFuncUInt64Callback(MockUInt64) + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseCallFuncPtr +func ReverseCallFuncPtr() string { + result := cross_call_master.CallFuncPtrCallback(MockPtr) + return fmt.Sprintf("0x%x", result) +} + +// plugify:export ReverseCallFuncFloat +func ReverseCallFuncFloat() string { + result := cross_call_master.CallFuncFloatCallback(MockFloat) + return fmt.Sprintf("%v", formatFlt32(result)) +} + +// plugify:export ReverseCallFuncDouble +func ReverseCallFuncDouble() string { + result := cross_call_master.CallFuncDoubleCallback(MockDouble) + return fmt.Sprintf("%v", formatFlt64(result)) +} + +// plugify:export ReverseCallFuncString +func ReverseCallFuncString() string { + result := cross_call_master.CallFuncStringCallback(MockString) + return result +} + +// plugify:export ReverseCallFuncAny +func ReverseCallFuncAny() string { + result := cross_call_master.CallFuncAnyCallback(MockAny) + return fmt.Sprintf("%c", result.(uint16)) +} + +// plugify:export ReverseCallFuncBoolVector +func ReverseCallFuncBoolVector() string { + result := cross_call_master.CallFuncBoolVectorCallback(MockBoolArray) + return formatArrayFmt(result, formatBool) +} + +// plugify:export ReverseCallFuncChar8Vector +func ReverseCallFuncChar8Vector() string { + result := cross_call_master.CallFuncChar8VectorCallback(MockChar8Array) + return formatArrayFmt(result, formatChr) +} + +// plugify:export ReverseCallFuncChar16Vector +func ReverseCallFuncChar16Vector() string { + result := cross_call_master.CallFuncChar16VectorCallback(MockChar16Array) + return formatArray(result) +} + +// plugify:export ReverseCallFuncInt8Vector +func ReverseCallFuncInt8Vector() string { + result := cross_call_master.CallFuncInt8VectorCallback(MockInt8Array) + return formatArray(result) +} + +// plugify:export ReverseCallFuncInt16Vector +func ReverseCallFuncInt16Vector() string { + result := cross_call_master.CallFuncInt16VectorCallback(MockInt16Array) + return formatArray(result) +} + +// plugify:export ReverseCallFuncInt32Vector +func ReverseCallFuncInt32Vector() string { + result := cross_call_master.CallFuncInt32VectorCallback(MockInt32Array) + return formatArray(result) +} + +// plugify:export ReverseCallFuncInt64Vector +func ReverseCallFuncInt64Vector() string { + result := cross_call_master.CallFuncInt64VectorCallback(MockInt64Array) + return formatArray(result) +} + +// plugify:export ReverseCallFuncUInt8Vector +func ReverseCallFuncUInt8Vector() string { + result := cross_call_master.CallFuncUInt8VectorCallback(MockUInt8Array) + return formatArray(result) +} + +// plugify:export ReverseCallFuncUInt16Vector +func ReverseCallFuncUInt16Vector() string { + result := cross_call_master.CallFuncUInt16VectorCallback(MockUInt16Array) + return formatArray(result) +} + +// plugify:export ReverseCallFuncUInt32Vector +func ReverseCallFuncUInt32Vector() string { + result := cross_call_master.CallFuncUInt32VectorCallback(MockUInt32Array) + return formatArray(result) +} + +// plugify:export ReverseCallFuncUInt64Vector +func ReverseCallFuncUInt64Vector() string { + result := cross_call_master.CallFuncUInt64VectorCallback(MockUInt64Array) + return formatArray(result) +} + +// plugify:export ReverseCallFuncPtrVector +func ReverseCallFuncPtrVector() string { + result := cross_call_master.CallFuncPtrVectorCallback(MockPtrArray) + return formatArrayFmt(result, formatPtr) +} + +// plugify:export ReverseCallFuncFloatVector +func ReverseCallFuncFloatVector() string { + result := cross_call_master.CallFuncFloatVectorCallback(MockFloatArray) + return formatArrayFmt(result, formatFlt32) +} + +// plugify:export ReverseCallFuncDoubleVector +func ReverseCallFuncDoubleVector() string { + result := cross_call_master.CallFuncDoubleVectorCallback(MockDoubleArray) + return formatArrayFmt(result, formatFlt64) +} + +// plugify:export ReverseCallFuncStringVector +func ReverseCallFuncStringVector() string { + result := cross_call_master.CallFuncStringVectorCallback(MockStringArray) + return formatArrayFmt(result, formatStr) +} + +// plugify:export ReverseCallFuncAnyVector +func ReverseCallFuncAnyVector() string { + result := cross_call_master.CallFuncAnyVectorCallback(MockAnyArray) + return formatArrayFmt(result, formatAny) +} + +// plugify:export ReverseCallFuncVec2Vector +func ReverseCallFuncVec2Vector() string { + result := cross_call_master.CallFuncVec2VectorCallback(MockVec2Array) + return formatArrayFmt(result, formatVector2) +} + +// plugify:export ReverseCallFuncVec3Vector +func ReverseCallFuncVec3Vector() string { + result := cross_call_master.CallFuncVec3VectorCallback(MockVec3Array) + return formatArrayFmt(result, formatVector3) +} + +// plugify:export ReverseCallFuncVec4Vector +func ReverseCallFuncVec4Vector() string { + result := cross_call_master.CallFuncVec4VectorCallback(MockVec4Array) + return formatArrayFmt(result, formatVector4) +} + +// plugify:export ReverseCallFuncMat4x4Vector +func ReverseCallFuncMat4x4Vector() string { + result := cross_call_master.CallFuncMat4x4VectorCallback(MockMat4x4Array) + return formatArrayFmt(result, formatMatrix4x4) +} + +// plugify:export ReverseCallFuncVec2 +func ReverseCallFuncVec2() string { + result := cross_call_master.CallFuncVec2Callback(MockVec2) + return formatVector2(result) +} + +// plugify:export ReverseCallFuncVec3 +func ReverseCallFuncVec3() string { + result := cross_call_master.CallFuncVec3Callback(MockVec3) + return formatVector3(result) +} + +// plugify:export ReverseCallFuncVec4 +func ReverseCallFuncVec4() string { + result := cross_call_master.CallFuncVec4Callback(MockVec4) + return formatVector4(result) +} + +// plugify:export ReverseCallFuncMat4x4 +func ReverseCallFuncMat4x4() string { + result := cross_call_master.CallFuncMat4x4Callback(MockMat4x4) + return formatMatrix4x4(result) +} + +// plugify:export ReverseCallFunc1 +func ReverseCallFunc1() string { + result := cross_call_master.CallFunc1Callback(MockFunc1) + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseCallFunc2 +func ReverseCallFunc2() string { + result := cross_call_master.CallFunc2Callback(MockFunc2) + return fmt.Sprintf("%c", result) +} + +// plugify:export ReverseCallFunc3 +func ReverseCallFunc3() string { + cross_call_master.CallFunc3Callback(MockFunc3) + return "" +} + +// plugify:export ReverseCallFunc4 +func ReverseCallFunc4() string { + result := cross_call_master.CallFunc4Callback(MockFunc4) + return formatVector4(result) +} + +// plugify:export ReverseCallFunc5 +func ReverseCallFunc5() string { + result := cross_call_master.CallFunc5Callback(MockFunc5) + return fmt.Sprintf("%t", result) +} + +// plugify:export ReverseCallFunc6 +func ReverseCallFunc6() string { + result := cross_call_master.CallFunc6Callback(MockFunc6) + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseCallFunc7 +func ReverseCallFunc7() string { + result := cross_call_master.CallFunc7Callback(MockFunc7) + return fmt.Sprintf("%v", formatFlt64(result)) +} + +// plugify:export ReverseCallFunc8 +func ReverseCallFunc8() string { + result := cross_call_master.CallFunc8Callback(MockFunc8) + return formatMatrix4x4(result) +} + +// plugify:export ReverseCallFunc9 +func ReverseCallFunc9() string { + cross_call_master.CallFunc9Callback(MockFunc9) + return "" +} + +// plugify:export ReverseCallFunc10 +func ReverseCallFunc10() string { + result := cross_call_master.CallFunc10Callback(MockFunc10) + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseCallFunc11 +func ReverseCallFunc11() string { + result := cross_call_master.CallFunc11Callback(MockFunc11) + return fmt.Sprintf("0x%x", result) +} + +// plugify:export ReverseCallFunc12 +func ReverseCallFunc12() string { + result := cross_call_master.CallFunc12Callback(MockFunc12) + return fmt.Sprintf("%t", result) +} + +// plugify:export ReverseCallFunc13 +func ReverseCallFunc13() string { + result := cross_call_master.CallFunc13Callback(MockFunc13) + return result +} + +// plugify:export ReverseCallFunc14 +func ReverseCallFunc14() string { + result := cross_call_master.CallFunc14Callback(MockFunc14) + return formatArrayFmt(result, formatStr) +} + +// plugify:export ReverseCallFunc15 +func ReverseCallFunc15() string { + result := cross_call_master.CallFunc15Callback(MockFunc15) + return fmt.Sprintf("%d", result) +} + +// plugify:export ReverseCallFunc16 +func ReverseCallFunc16() string { + result := cross_call_master.CallFunc16Callback(MockFunc16) + return fmt.Sprintf("0x%x", result) +} + +// plugify:export ReverseCallFunc17 +func ReverseCallFunc17() string { + result := cross_call_master.CallFunc17Callback(MockFunc17) + return result +} + +// plugify:export ReverseCallFunc18 +func ReverseCallFunc18() string { + result := cross_call_master.CallFunc18Callback(MockFunc18) + return result +} + +// plugify:export ReverseCallFunc19 +func ReverseCallFunc19() string { + result := cross_call_master.CallFunc19Callback(MockFunc19) + return result +} + +// plugify:export ReverseCallFunc20 +func ReverseCallFunc20() string { + result := cross_call_master.CallFunc20Callback(MockFunc20) + return result +} + +// plugify:export ReverseCallFunc21 +func ReverseCallFunc21() string { + result := cross_call_master.CallFunc21Callback(MockFunc21) + return result +} + +// plugify:export ReverseCallFunc22 +func ReverseCallFunc22() string { + result := cross_call_master.CallFunc22Callback(MockFunc22) + return result +} + +// plugify:export ReverseCallFunc23 +func ReverseCallFunc23() string { + result := cross_call_master.CallFunc23Callback(MockFunc23) + return result +} + +// plugify:export ReverseCallFunc24 +func ReverseCallFunc24() string { + result := cross_call_master.CallFunc24Callback(MockFunc24) + return result +} + +// plugify:export ReverseCallFunc25 +func ReverseCallFunc25() string { + result := cross_call_master.CallFunc25Callback(MockFunc25) + return result +} + +// plugify:export ReverseCallFunc26 +func ReverseCallFunc26() string { + result := cross_call_master.CallFunc26Callback(MockFunc26) + return result +} + +// plugify:export ReverseCallFunc27 +func ReverseCallFunc27() string { + result := cross_call_master.CallFunc27Callback(MockFunc27) + return result +} + +// plugify:export ReverseCallFunc28 +func ReverseCallFunc28() string { + result := cross_call_master.CallFunc28Callback(MockFunc28) + return result +} + +// plugify:export ReverseCallFunc29 +func ReverseCallFunc29() string { + result := cross_call_master.CallFunc29Callback(MockFunc29) + return result +} + +// plugify:export ReverseCallFunc30 +func ReverseCallFunc30() string { + result := cross_call_master.CallFunc30Callback(MockFunc30) + return result +} + +// plugify:export ReverseCallFunc31 +func ReverseCallFunc31() string { + result := cross_call_master.CallFunc31Callback(MockFunc31) + return result +} + +// plugify:export ReverseCallFunc32 +func ReverseCallFunc32() string { + result := cross_call_master.CallFunc32Callback(MockFunc32) + return result +} + +// plugify:export ReverseCallFunc33 +func ReverseCallFunc33() string { + result := cross_call_master.CallFunc33Callback(MockFunc33) + return result +} + +// plugify:export ReverseCallFuncEnum +func ReverseCallFuncEnum() string { + result := cross_call_master.CallFuncEnumCallback(MockFuncEnum) + return result +} + +func log(message string) { + // TODO Only logs in debug builds + // Use build tag: //go:build debug + fmt.Println(message) +} + +func BasicLifecycle() string { + log("TEST 1: Basic Lifecycle") + log("_______________________") + + initialAlive := cross_call_master.ResourceHandleGetAliveCount() + initialCreated := cross_call_master.ResourceHandleGetTotalCreated() + + func() { + resource := cross_call_master.NewResourceHandleResourceHandleCreate(1, "Test1") + defer resource.Close() + + id, _ := resource.GetId() + alive := cross_call_master.ResourceHandleGetAliveCount() + + log(fmt.Sprintf("v Created ResourceHandle ID: %d", id)) + log(fmt.Sprintf("v Alive count increased: %d", alive)) + }() + + finalAlive := cross_call_master.ResourceHandleGetAliveCount() + finalCreated := cross_call_master.ResourceHandleGetTotalCreated() + finalDestroyed := cross_call_master.ResourceHandleGetTotalDestroyed() + + log(fmt.Sprintf("v Destructor called, alive count: %d", finalAlive)) + log(fmt.Sprintf("v Total created: %d", finalCreated-initialCreated)) + log(fmt.Sprintf("v Total destroyed: %d", finalDestroyed)) + + if finalAlive == initialAlive && finalCreated == finalDestroyed { + log("v TEST 1 PASSED: Lifecycle working correctly\n") + return "true" + } else { + log("x TEST 1 FAILED: Lifecycle mismatch!\n") + return "false" + } +} + +func StateManagement() string { + log("TEST 2: State Management") + log("________________________") + + resource := cross_call_master.NewResourceHandleResourceHandleCreate(2, "StateTest") + defer resource.Close() + + _ = resource.IncrementCounter() + _ = resource.IncrementCounter() + _ = resource.IncrementCounter() + counter, _ := resource.GetCounter() + log(fmt.Sprintf("v Counter incremented 3 times: %d", counter)) + + _ = resource.SetName("StateTestModified") + newName, _ := resource.GetName() + log(fmt.Sprintf("v Name changed to: %s", newName)) + + _ = resource.AddData(1.1) + _ = resource.AddData(2.2) + _ = resource.AddData(3.3) + data, _ := resource.GetData() + log(fmt.Sprintf("v Added %d data points", len(data))) + + if counter == 3 && newName == "StateTestModified" && len(data) == 3 { + log("v TEST 2 PASSED: State management working\n") + return "true" + } else { + log("x TEST 2 FAILED: State not preserved!\n") + return "false" + } +} + +func MultipleInstances() string { + log("TEST 3: Multiple Instances") + log("__________________________") + + beforeAlive := cross_call_master.ResourceHandleGetAliveCount() + + func() { + r1 := cross_call_master.NewResourceHandleResourceHandleCreate(10, "Instance1") + defer r1.Close() + r2 := cross_call_master.NewResourceHandleResourceHandleCreate(20, "Instance2") + defer r2.Close() + r3 := cross_call_master.NewResourceHandleResourceHandleCreateDefault() + defer r3.Close() + + duringAlive := cross_call_master.ResourceHandleGetAliveCount() + id1, _ := r1.GetId() + id2, _ := r2.GetId() + id3, _ := r3.GetId() + + log(fmt.Sprintf("v Created 3 instances, alive: %d", duringAlive)) + log(fmt.Sprintf("v R1 ID: %d, R2 ID: %d, R3 ID: %d", id1, id2, id3)) + + if duringAlive-beforeAlive == 3 { + log("v All 3 instances tracked correctly") + } + }() + + afterAlive := cross_call_master.ResourceHandleGetAliveCount() + + if afterAlive == beforeAlive { + log("v TEST 3 PASSED: All instances destroyed properly\n") + return "true" + } else { + log(fmt.Sprintf("x TEST 3 FAILED: Leak detected! Before: %d, After: %d\n", beforeAlive, afterAlive)) + return "false" + } +} + +func CounterWithoutDestructor() string { + log("TEST 4: Counter (No Destructor)") + log("________________________________") + + counter := cross_call_master.NewCounterCounterCreate(100) + initialValue, _ := counter.GetValue() + log(fmt.Sprintf("v Created Counter with value: %d", initialValue)) + + _ = counter.Increment() + _ = counter.Increment() + _ = counter.Add(50) + value, _ := counter.GetValue() + log(fmt.Sprintf("v After operations, value: %d", value)) + + isPositive, _ := counter.IsPositive() + log(fmt.Sprintf("v Is positive: %t", isPositive)) + + if value == 152 && isPositive { + log("v TEST 4 PASSED: Counter operations working\n") + return "true" + } else { + log("x TEST 4 FAILED: Counter operations incorrect\n") + return "false" + } +} + +func StaticMethods() string { + log("TEST 5: Static Methods") + log("______________________") + + alive := cross_call_master.ResourceHandleGetAliveCount() + created := cross_call_master.ResourceHandleGetTotalCreated() + destroyed := cross_call_master.ResourceHandleGetTotalDestroyed() + log(fmt.Sprintf("v ResourceHandle stats - Alive: %d, Created: %d, Destroyed: %d", alive, created, destroyed)) + + cmp1 := cross_call_master.CounterCompare(100, 50) + cmp2 := cross_call_master.CounterCompare(50, 100) + cmp3 := cross_call_master.CounterCompare(50, 50) + log(fmt.Sprintf("v Counter.Compare(100, 50) = %d (expected 1)", cmp1)) + log(fmt.Sprintf("v Counter.Compare(50, 100) = %d (expected -1)", cmp2)) + log(fmt.Sprintf("v Counter.Compare(50, 50) = %d (expected 0)", cmp3)) + + sum := cross_call_master.CounterSum([]int64{1, 2, 3, 4, 5}) + log(fmt.Sprintf("v Counter.Sum([1,2,3,4,5]) = %d (expected 15)", sum)) + + if cmp1 == 1 && cmp2 == -1 && cmp3 == 0 && sum == 15 { + log("v TEST 5 PASSED: Static methods working\n") + return "true" + } else { + log("x TEST 5 FAILED: Static methods incorrect\n") + return "false" + } +} + +func MemoryLeakDetection() string { + log("TEST 6: Memory Leak Detection") + log("______________________________") + + beforeAlive := cross_call_master.ResourceHandleGetAliveCount() + + { + leaked := cross_call_master.NewResourceHandleResourceHandleCreate(999, "IntentionalLeak") + id, _ := leaked.GetId() + log(fmt.Sprintf("v Created resource ID: %d", id)) + leaked = nil + } + + runtime.GC() + runtime.Gosched() + + afterAlive := cross_call_master.ResourceHandleGetAliveCount() + + log(fmt.Sprintf("v Before leak test: %d alive", beforeAlive)) + log(fmt.Sprintf("v After release: %d alive", afterAlive)) + + if afterAlive == beforeAlive { + log("v TEST 6 PASSED: Finalizer cleaned up leaked resource\n") + return "true" + } else { + log("x TEST 6 FAILED: Resource still alive (will be cleaned at plugin shutdown)\n") + return "false" + } +} + +func ExceptionHandling() string { + log("TEST 7: Exception Handling") + log("__________________________") + + resource := cross_call_master.NewResourceHandleResourceHandleCreate(777, "ExceptionTest") + resource.Close() + + _, err := resource.GetId() + if err != nil { + log(fmt.Sprintf("v Caught expected error: %v", err)) + log("v TEST 7 PASSED: Exception handling working\n") + return "true" + } else { + log("x TEST 7 FAILED: No error thrown!\n") + return "false" + } +} + +func OwnershipTransfer() string { + log("TEST 7: Ownership Transfer (get + release)") + log("─────────────────────────────────────────") + + initialAlive := cross_call_master.ResourceHandleGetAliveCount() + //initialCreated := cross_call_master.ResourceHandleGetTotalCreated() + + resource := cross_call_master.NewResourceHandleResourceHandleCreate(42, "OwnershipTest") + id, _ := resource.GetId(); + log(fmt.Sprintf("v Created ResourceHandle ID: %d", id)) + + // Get internal wrapper (simulate internal pointer access) + wrapper := resource.Get() + log(fmt.Sprintf("v get() returned internal wrapper: 0x%x", wrapper)) + + // Release ownership + handle := resource.Release() + log(fmt.Sprintf("v release() returned handle: 0x%x", handle)) + + if wrapper != handle { + log("x TEST 7 FAILED: get() did not return internal wrapper") + return "false" + } + + // Check if resource is invalid after release + _, err := resource.GetId() + + if err != nil { + log("v ResourceHandle is invalid after release()"); + } else { + log("x TEST 7 FAILED: ResourceHandle still accessible after release()"); + return "false"; + } + + // Check that handle is now owned externally and alive count updated correctly + aliveAfterRelease := cross_call_master.ResourceHandleGetAliveCount() + if aliveAfterRelease != initialAlive + 1 { + log(fmt.Sprintf("x TEST 7 FAILED: Alive count mismatch after release. " + + "Expected %d, got %d", + initialAlive + 1, aliveAfterRelease)) + return "false" + } + + cross_call_master.ResourceHandleDestroy(handle) + + log("v TEST 7 PASSED: Ownership transfer working correctly\n") + return "true" +} + +var ReverseTest = map[string]func() string{ + "NoParamReturnVoid": ReverseNoParamReturnVoid, + "NoParamReturnBool": ReverseNoParamReturnBool, + "NoParamReturnChar8": ReverseNoParamReturnChar8, + "NoParamReturnChar16": ReverseNoParamReturnChar16, + "NoParamReturnInt8": ReverseNoParamReturnInt8, + "NoParamReturnInt16": ReverseNoParamReturnInt16, + "NoParamReturnInt32": ReverseNoParamReturnInt32, + "NoParamReturnInt64": ReverseNoParamReturnInt64, + "NoParamReturnUInt8": ReverseNoParamReturnUInt8, + "NoParamReturnUInt16": ReverseNoParamReturnUInt16, + "NoParamReturnUInt32": ReverseNoParamReturnUInt32, + "NoParamReturnUInt64": ReverseNoParamReturnUInt64, + "NoParamReturnPointer": ReverseNoParamReturnPointer, + "NoParamReturnFloat": ReverseNoParamReturnFloat, + "NoParamReturnDouble": ReverseNoParamReturnDouble, + "NoParamReturnFunction": ReverseNoParamReturnFunction, + "NoParamReturnString": ReverseNoParamReturnString, + "NoParamReturnAny": ReverseNoParamReturnAny, + "NoParamReturnArrayBool": ReverseNoParamReturnArrayBool, + "NoParamReturnArrayChar8": ReverseNoParamReturnArrayChar8, + "NoParamReturnArrayChar16": ReverseNoParamReturnArrayChar16, + "NoParamReturnArrayInt8": ReverseNoParamReturnArrayInt8, + "NoParamReturnArrayInt16": ReverseNoParamReturnArrayInt16, + "NoParamReturnArrayInt32": ReverseNoParamReturnArrayInt32, + "NoParamReturnArrayInt64": ReverseNoParamReturnArrayInt64, + "NoParamReturnArrayUInt8": ReverseNoParamReturnArrayUInt8, + "NoParamReturnArrayUInt16": ReverseNoParamReturnArrayUInt16, + "NoParamReturnArrayUInt32": ReverseNoParamReturnArrayUInt32, + "NoParamReturnArrayUInt64": ReverseNoParamReturnArrayUInt64, + "NoParamReturnArrayPointer": ReverseNoParamReturnArrayPointer, + "NoParamReturnArrayFloat": ReverseNoParamReturnArrayFloat, + "NoParamReturnArrayDouble": ReverseNoParamReturnArrayDouble, + "NoParamReturnArrayString": ReverseNoParamReturnArrayString, + "NoParamReturnArrayAny": ReverseNoParamReturnArrayAny, + "NoParamReturnVector2": ReverseNoParamReturnVector2, + "NoParamReturnVector3": ReverseNoParamReturnVector3, + "NoParamReturnVector4": ReverseNoParamReturnVector4, + "NoParamReturnMatrix4x4": ReverseNoParamReturnMatrix4x4, + "Param1": ReverseParam1, + "Param2": ReverseParam2, + "Param3": ReverseParam3, + "Param4": ReverseParam4, + "Param5": ReverseParam5, + "Param6": ReverseParam6, + "Param7": ReverseParam7, + "Param8": ReverseParam8, + "Param9": ReverseParam9, + "Param10": ReverseParam10, + "ParamRef1": ReverseParamRef1, + "ParamRef2": ReverseParamRef2, + "ParamRef3": ReverseParamRef3, + "ParamRef4": ReverseParamRef4, + "ParamRef5": ReverseParamRef5, + "ParamRef6": ReverseParamRef6, + "ParamRef7": ReverseParamRef7, + "ParamRef8": ReverseParamRef8, + "ParamRef9": ReverseParamRef9, + "ParamRef10": ReverseParamRef10, + "ParamRefArrays": ReverseParamRefVectors, + "ParamAllPrimitives": ReverseParamAllPrimitives, + "ParamEnum": ReverseParamEnum, + "ParamEnumRef": ReverseParamEnumRef, + "ParamVariant": ReverseParamVariant, + "ParamVariantRef": ReverseParamVariantRef, + "CallFuncVoid": ReverseCallFuncVoid, + "CallFuncBool": ReverseCallFuncBool, + "CallFuncChar8": ReverseCallFuncChar8, + "CallFuncChar16": ReverseCallFuncChar16, + "CallFuncInt8": ReverseCallFuncInt8, + "CallFuncInt16": ReverseCallFuncInt16, + "CallFuncInt32": ReverseCallFuncInt32, + "CallFuncInt64": ReverseCallFuncInt64, + "CallFuncUInt8": ReverseCallFuncUInt8, + "CallFuncUInt16": ReverseCallFuncUInt16, + "CallFuncUInt32": ReverseCallFuncUInt32, + "CallFuncUInt64": ReverseCallFuncUInt64, + "CallFuncPtr": ReverseCallFuncPtr, + "CallFuncFloat": ReverseCallFuncFloat, + "CallFuncDouble": ReverseCallFuncDouble, + "CallFuncString": ReverseCallFuncString, + "CallFuncAny": ReverseCallFuncAny, + "CallFuncBoolVector": ReverseCallFuncBoolVector, + "CallFuncChar8Vector": ReverseCallFuncChar8Vector, + "CallFuncChar16Vector": ReverseCallFuncChar16Vector, + "CallFuncInt8Vector": ReverseCallFuncInt8Vector, + "CallFuncInt16Vector": ReverseCallFuncInt16Vector, + "CallFuncInt32Vector": ReverseCallFuncInt32Vector, + "CallFuncInt64Vector": ReverseCallFuncInt64Vector, + "CallFuncUInt8Vector": ReverseCallFuncUInt8Vector, + "CallFuncUInt16Vector": ReverseCallFuncUInt16Vector, + "CallFuncUInt32Vector": ReverseCallFuncUInt32Vector, + "CallFuncUInt64Vector": ReverseCallFuncUInt64Vector, + "CallFuncPtrVector": ReverseCallFuncPtrVector, + "CallFuncFloatVector": ReverseCallFuncFloatVector, + "CallFuncDoubleVector": ReverseCallFuncDoubleVector, + "CallFuncStringVector": ReverseCallFuncStringVector, + "CallFuncAnyVector": ReverseCallFuncAnyVector, + "CallFuncVec2Vector": ReverseCallFuncVec2Vector, + "CallFuncVec3Vector": ReverseCallFuncVec3Vector, + "CallFuncVec4Vector": ReverseCallFuncVec4Vector, + "CallFuncMat4x4Vector": ReverseCallFuncMat4x4Vector, + "CallFuncVec2": ReverseCallFuncVec2, + "CallFuncVec3": ReverseCallFuncVec3, + "CallFuncVec4": ReverseCallFuncVec4, + "CallFuncMat4x4": ReverseCallFuncMat4x4, + "CallFunc1": ReverseCallFunc1, + "CallFunc2": ReverseCallFunc2, + "CallFunc3": ReverseCallFunc3, + "CallFunc4": ReverseCallFunc4, + "CallFunc5": ReverseCallFunc5, + "CallFunc6": ReverseCallFunc6, + "CallFunc7": ReverseCallFunc7, + "CallFunc8": ReverseCallFunc8, + "CallFunc9": ReverseCallFunc9, + "CallFunc10": ReverseCallFunc10, + "CallFunc11": ReverseCallFunc11, + "CallFunc12": ReverseCallFunc12, + "CallFunc13": ReverseCallFunc13, + "CallFunc14": ReverseCallFunc14, + "CallFunc15": ReverseCallFunc15, + "CallFunc16": ReverseCallFunc16, + "CallFunc17": ReverseCallFunc17, + "CallFunc18": ReverseCallFunc18, + "CallFunc19": ReverseCallFunc19, + "CallFunc20": ReverseCallFunc20, + "CallFunc21": ReverseCallFunc21, + "CallFunc22": ReverseCallFunc22, + "CallFunc23": ReverseCallFunc23, + "CallFunc24": ReverseCallFunc24, + "CallFunc25": ReverseCallFunc25, + "CallFunc26": ReverseCallFunc26, + "CallFunc27": ReverseCallFunc27, + "CallFunc28": ReverseCallFunc28, + "CallFunc29": ReverseCallFunc29, + "CallFunc30": ReverseCallFunc30, + "CallFunc31": ReverseCallFunc31, + "CallFunc32": ReverseCallFunc32, + "CallFunc33": ReverseCallFunc33, + "CallFuncEnum": ReverseCallFuncEnum, + + "ClassBasicLifecycle": BasicLifecycle, + "ClassStateManagement": StateManagement, + "ClassMultipleInstances": MultipleInstances, + "ClassCounterWithoutDestructor": CounterWithoutDestructor, + "ClassStaticMethods": StaticMethods, + "ClassMemoryLeakDetection": MemoryLeakDetection, + "ClassExceptionHandling": ExceptionHandling, + "ClassOwnershipTransfer": OwnershipTransfer, +} + +// plugify:export ReverseCall +func ReverseCall(test string) { + // Retrieve the function from the map + if method, exists := ReverseTest[test]; exists { + // Call the function and get the result + result := method() + if result != "" { + // Call the ReverseReturn function with the result + cross_call_master.ReverseReturn(result) + } + } else { + // Print an error message if the function is not found + fmt.Printf("Method '%s' not found.\n", test) + } +} diff --git a/test/cross_call_worker/generator.go b/test/cross_call_worker/generator.go index cfd9268..9f5e7b2 100644 --- a/test/cross_call_worker/generator.go +++ b/test/cross_call_worker/generator.go @@ -3,8 +3,44 @@ package main -import "github.com/untrustedmodders/go-plugify" +import ( + "flag" + "fmt" + "github.com/untrustedmodders/go-plugify" + "os" +) func main() { - plugify.Generate("main", "./") + var ( + patterns = flag.String("patterns", "./...", "Package patterns to analyze") + output = flag.String("output", "", "Output manifest file (default: .pplugin)") + name = flag.String("name", "", "Plugin name (default: package name)") + version = flag.String("version", "1.0.0", "Plugin version") + description = flag.String("description", "", "Plugin description") + author = flag.String("author", "", "Plugin author") + website = flag.String("website", "", "Plugin website") + license = flag.String("license", "", "Plugin license") + entry = flag.String("entry", "", "Plugin entry point (default: )") + target = flag.String("package", "main", "Autoexports package (default: main)") + ) + + flag.Parse() + + // Log what we're doing + fmt.Println("Starting plugin manifest generation...") + fmt.Printf("Package patterns: %s\n", *patterns) + if *output != "" { + fmt.Printf("Output file: %s\n", *output) + } + if *name != "" { + fmt.Printf("Plugin name: %s\n", *name) + } + fmt.Printf("Version: %s\n", *version) + + // Call the generator with error handling + err := plugify.Generate(*patterns, *output, *name, *version, *description, *author, *website, *license, *entry, *target) + if err != nil { + fmt.Fprintf(os.Stderr, "Error generating plugin manifest: %v\n", err) + os.Exit(1) + } } diff --git a/test/cross_call_worker/go.mod b/test/cross_call_worker/go.mod index 01ab5d4..6ef6537 100644 --- a/test/cross_call_worker/go.mod +++ b/test/cross_call_worker/go.mod @@ -2,4 +2,10 @@ module plugify-plugin go 1.24.0 -require github.com/untrustedmodders/go-plugify v1.2.2 +require github.com/untrustedmodders/go-plugify v1.3.0 + +require ( + golang.org/x/mod v0.30.0 // indirect + golang.org/x/sync v0.18.0 // indirect + golang.org/x/tools v0.39.0 // indirect +) diff --git a/test/cross_call_worker/go.sum b/test/cross_call_worker/go.sum index 57d1c0c..fbe4b77 100644 --- a/test/cross_call_worker/go.sum +++ b/test/cross_call_worker/go.sum @@ -1,3 +1,11 @@ github.com/untrustedmodders/go-plugify v1.1.11/go.mod h1:c5w+u1HBAOxLPJzBwT0OBpfokLuZxGvnjtNSTOmynWc= github.com/untrustedmodders/go-plugify v1.2.2 h1:Qj9YWS6vCJJ1TwXN50iRgYOoekNkiHZNL6by2VVlpzU= github.com/untrustedmodders/go-plugify v1.2.2/go.mod h1:c5w+u1HBAOxLPJzBwT0OBpfokLuZxGvnjtNSTOmynWc= +github.com/untrustedmodders/go-plugify v1.3.0 h1:2eg2oo06MhDC95w+6i5jRCPwnFEjFqp7Xl5o4uHCFvI= +github.com/untrustedmodders/go-plugify v1.3.0/go.mod h1:JvcId+YUagSthPxrLC5NT2MxlfhnIGfoOuC2iEMqXgE= +golang.org/x/mod v0.30.0 h1:fDEXFVZ/fmCKProc/yAXXUijritrDzahmwwefnjoPFk= +golang.org/x/mod v0.30.0/go.mod h1:lAsf5O2EvJeSFMiBxXDki7sCgAxEUcZHXoXMKT4GJKc= +golang.org/x/sync v0.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I= +golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= +golang.org/x/tools v0.39.0 h1:ik4ho21kwuQln40uelmciQPp9SipgNDdrafrYA4TmQQ= +golang.org/x/tools v0.39.0/go.mod h1:JnefbkDPyD8UU2kI5fuf8ZX4/yUeh9W877ZeBONxUqQ= diff --git a/test/cross_call_worker/main.go b/test/cross_call_worker/main.go index 1c496b2..61e7786 100644 --- a/test/cross_call_worker/main.go +++ b/test/cross_call_worker/main.go @@ -1,103 +1,12 @@ package main -import "C" import ( "fmt" "github.com/untrustedmodders/go-plugify" - "math" - "plugify-plugin/cross_call_master" "runtime/debug" - "strconv" - "strings" - "unsafe" ) -type Example = int32 - -const ( - First Example = 1 - Second Example = 2 - Third Example = 3 - Forth Example = 4 -) - -type NoParamReturnFunctionFunc func() -type FuncVoid func() -type FuncBool func() bool -type FuncChar8 func() int8 -type FuncChar16 func() uint16 -type FuncInt8 func() int8 -type FuncInt16 func() int16 -type FuncInt32 func() int32 -type FuncInt64 func() int64 -type FuncUInt8 func() uint8 -type FuncUInt16 func() uint16 -type FuncUInt32 func() uint32 -type FuncUInt64 func() uint64 -type FuncPtr func() uintptr -type FuncFloat func() float32 -type FuncDouble func() float64 -type FuncString func() string -type FuncAny func() any -type FuncFunction func() uintptr -type FuncBoolVector func() []bool -type FuncChar8Vector func() []int8 -type FuncChar16Vector func() []uint16 -type FuncInt8Vector func() []int8 -type FuncInt16Vector func() []int16 -type FuncInt32Vector func() []int32 -type FuncInt64Vector func() []int64 -type FuncUInt8Vector func() []uint8 -type FuncUInt16Vector func() []uint16 -type FuncUInt32Vector func() []uint32 -type FuncUInt64Vector func() []uint64 -type FuncPtrVector func() []uintptr -type FuncFloatVector func() []float32 -type FuncDoubleVector func() []float64 -type FuncStringVector func() []string -type FuncAnyVector func() []any -type FuncVec2Vector func() []plugify.Vector2 -type FuncVec3Vector func() []plugify.Vector3 -type FuncVec4Vector func() []plugify.Vector4 -type FuncMat4x4Vector func() []plugify.Matrix4x4 -type FuncVec2 func() plugify.Vector2 -type FuncVec3 func() plugify.Vector3 -type FuncVec4 func() plugify.Vector4 -type FuncMat4x4 func() plugify.Matrix4x4 -type Func1 func(*plugify.Vector3) int32 -type Func2 func(float32, int64) int8 -type Func3 func(uintptr, *plugify.Vector4, string) -type Func4 func(bool, int32, uint16, *plugify.Matrix4x4) plugify.Vector4 -type Func5 func(int8, *plugify.Vector2, uintptr, float64, []uint64) bool -type Func6 func(string, float32, []float32, int16, []uint8, uintptr) int64 -type Func7 func([]int8, uint16, uint16, []uint32, *plugify.Vector4, bool, uint64) float64 -type Func8 func(*plugify.Vector3, []uint32, int16, bool, *plugify.Vector4, []uint16, uint16, int32) plugify.Matrix4x4 -type Func9 func(float32, *plugify.Vector2, []int8, uint64, bool, string, *plugify.Vector4, int16, uintptr) -type Func10 func(*plugify.Vector4, *plugify.Matrix4x4, []uint32, uint64, []int8, int32, bool, *plugify.Vector2, int64, float64) uint32 -type Func11 func([]bool, uint16, uint8, float64, *plugify.Vector3, []int8, int64, uint16, float32, *plugify.Vector2, uint32) uintptr -type Func12 func(uintptr, []float64, uint32, float64, bool, int32, int8, uint64, float32, []uintptr, int64, int8) bool -type Func13 func(int64, []int8, uint16, float32, []bool, *plugify.Vector4, string, int32, *plugify.Vector3, uintptr, *plugify.Vector2, []uint8, int16) string -type Func14 func([]int8, []uint32, *plugify.Matrix4x4, bool, uint16, int32, []float32, uint16, []uint8, int8, *plugify.Vector3, *plugify.Vector4, float64, uintptr) []string -type Func15 func([]int16, *plugify.Matrix4x4, *plugify.Vector4, uintptr, uint64, []uint32, bool, float32, []uint16, uint8, int32, *plugify.Vector2, uint16, float64, []uint8) int16 -type Func16 func([]bool, int16, []int8, *plugify.Vector4, *plugify.Matrix4x4, *plugify.Vector2, []uint64, []int8, string, int64, []uint32, *plugify.Vector3, float32, float64, int8, uint16) uintptr -type Func17 func(*int32) -type Func18 func(*int8, *int16) plugify.Vector2 -type Func19 func(*uint32, *plugify.Vector3, *[]uint32) -type Func20 func(*uint16, *plugify.Vector4, *[]uint64, *int8) int32 -type Func21 func(*plugify.Matrix4x4, *[]int32, *plugify.Vector2, *bool, *float64) float32 -type Func22 func(*uintptr, *uint32, *[]float64, *int16, *string, *plugify.Vector4) uint64 -type Func23 func(*uint64, *plugify.Vector2, *[]int16, *uint16, *float32, *int8, *[]uint8) -type Func24 func(*[]int8, *int64, *[]uint8, *plugify.Vector4, *uint64, *[]uintptr, *float64, *[]uintptr) plugify.Matrix4x4 -type Func25 func(*int32, *[]uintptr, *bool, *uint8, *string, *plugify.Vector3, *int64, *plugify.Vector4, *uint16) float64 -type Func26 func(*uint16, *plugify.Vector2, *plugify.Matrix4x4, *[]float32, *int16, *uint64, *uint32, *[]uint16, *uintptr, *bool) int8 -type Func27 func(*float32, *plugify.Vector3, *uintptr, *plugify.Vector2, *[]int16, *plugify.Matrix4x4, *bool, *plugify.Vector4, *int8, *int32, *[]uint8) uint8 -type Func28 func(*uintptr, *uint16, *[]uint32, *plugify.Matrix4x4, *float32, *plugify.Vector4, *string, *[]uint64, *int64, *bool, *plugify.Vector3, *[]float32) string -type Func29 func(*plugify.Vector4, *int32, *[]int8, *float64, *bool, *int8, *[]uint16, *float32, *string, *plugify.Matrix4x4, *uint64, *plugify.Vector3, *[]int64) []string -type Func30 func(*uintptr, *plugify.Vector4, *int64, *[]uint32, *bool, *string, *plugify.Vector3, *[]uint8, *float32, *plugify.Vector2, *plugify.Matrix4x4, *int8, *[]float32, *float64) int32 -type Func31 func(*int8, *uint32, *[]uint64, *plugify.Vector4, *string, *bool, *int64, *plugify.Vector2, *int8, *uint16, *[]int16, *plugify.Matrix4x4, *plugify.Vector3, *float32, *[]float64) plugify.Vector3 -type Func32 func(*int32, *uint16, *[]int8, *plugify.Vector4, *uintptr, *[]uint32, *plugify.Matrix4x4, *uint64, *string, *int64, *plugify.Vector2, *[]int8, *bool, *plugify.Vector3, *uint8, *[]uint16) -type Func33 func(*any) -type FuncEnum func(Example, *[]Example) []Example +func main() {} func init() { plugify.OnPluginStart(func() { @@ -112,2141 +21,3 @@ func init() { return debug.Stack() // workaround for could not import runtime/debug inside plugify package }) } - -func NoParamReturnVoid() { - fmt.Println("Go: NoParamReturnVoid") -} - -func NoParamReturnBool() bool { - fmt.Println("Go: NoParamReturnBool") - return true -} - -func NoParamReturnChar8() int8 { - fmt.Println("Go: NoParamReturnChar16") - return math.MaxInt8 -} - -func NoParamReturnChar16() uint16 { - fmt.Println("Go: NoParamReturnChar16") - return math.MaxUint16 -} - -func NoParamReturnInt8() int8 { - fmt.Println("Go: NoParamReturnInt8") - return math.MaxInt8 -} - -func NoParamReturnInt16() int16 { - fmt.Println("Go: NoParamReturnInt16") - return math.MaxInt16 -} - -func NoParamReturnInt32() int32 { - fmt.Println("Go: NoParamReturnInt32") - return math.MaxInt32 -} - -func NoParamReturnInt64() int64 { - fmt.Println("Go: NoParamReturnInt64") - return math.MaxInt64 -} - -func NoParamReturnUInt8() uint8 { - fmt.Println("Go: NoParamReturnUInt8") - return math.MaxUint8 -} - -func NoParamReturnUInt16() uint16 { - fmt.Println("Go: NoParamReturnUInt16") - return math.MaxUint16 -} - -func NoParamReturnUInt32() uint32 { - fmt.Println("Go: NoParamReturnUInt32") - return math.MaxUint32 -} - -func NoParamReturnUInt64() uint64 { - fmt.Println("Go: NoParamReturnUInt64") - return math.MaxUint64 -} - -func NoParamReturnPointer() uintptr { - fmt.Println("Go: NoParamReturnPointer") - return uintptr(1) -} - -func NoParamReturnFloat() float32 { - fmt.Println("Go: NoParamReturnFloat") - return math.MaxFloat32 -} - -func NoParamReturnDouble() float64 { - fmt.Println("Go: NoParamReturnDouble") - return math.MaxFloat64 -} - -func NoParamReturnFunction() NoParamReturnFunctionFunc { - fmt.Println("Go: NoParamReturnFunction") - return func() { - fmt.Println("Go: NoParamReturnFunctionFunc") - } -} - -func NoParamReturnString() string { - fmt.Println("Go: NoParamReturnString") - return "Hello World" -} - -func NoParamReturnAny() any { - fmt.Println("NoParamReturnAny") - return []float64{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0} -} - -func NoParamReturnArrayBool() []bool { - fmt.Println("Go: NoParamReturnArrayBool") - return []bool{true, false} -} - -func NoParamReturnArrayChar8() []int8 { - fmt.Println("Go: NoParamReturnArrayChar8") - return []int8{'a', 'b', 'c', 'd'} -} - -func NoParamReturnArrayChar16() []uint16 { - fmt.Println("Go: NoParamReturnArrayChar16") - return []uint16{'a', 'b', 'c', 'd'} -} - -func NoParamReturnArrayInt8() []int8 { - fmt.Println("Go: NoParamReturnArrayInt8") - return []int8{-3, -2, -1, 0, 1} -} - -func NoParamReturnArrayInt16() []int16 { - fmt.Println("Go: NoParamReturnArrayInt16") - return []int16{-4, -3, -2, -1, 0, 1} -} - -func NoParamReturnArrayInt32() []int32 { - fmt.Println("Go: NoParamReturnArrayInt32") - return []int32{-5, -4, -3, -2, -1, 0, 1} -} - -func NoParamReturnArrayInt64() []int64 { - fmt.Println("Go: NoParamReturnArrayInt64") - return []int64{-6, -5, -4, -3, -2, -1, 0, 1} -} - -func NoParamReturnArrayUInt8() []uint8 { - fmt.Println("Go: NoParamReturnArrayUInt8") - return []uint8{0, 1, 2, 3, 4, 5, 6, 7, 8} -} - -func NoParamReturnArrayUInt16() []uint16 { - fmt.Println("Go: NoParamReturnArrayUInt16") - return []uint16{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} -} - -func NoParamReturnArrayUInt32() []uint32 { - fmt.Println("Go: NoParamReturnArrayUInt32") - return []uint32{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10} -} - -func NoParamReturnArrayUInt64() []uint64 { - fmt.Println("Go: NoParamReturnArrayUInt64") - return []uint64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11} -} - -func NoParamReturnArrayPointer() []uintptr { - fmt.Println("Go: NoParamReturnArrayPointer") - return []uintptr{0, 1, 2, 3} -} - -func NoParamReturnArrayFloat() []float32 { - fmt.Println("Go: NoParamReturnArrayFloat") - return []float32{-12.34, 0.0, 12.34} -} - -func NoParamReturnArrayDouble() []float64 { - fmt.Println("Go: NoParamReturnArrayDouble") - return []float64{-12.345, 0.0, 12.345} -} - -func NoParamReturnArrayString() []string { - fmt.Println("Go: NoParamReturnArrayString") - return []string{ - "1st string", "2nd string", - "3rd element string (Should be big enough to avoid small string optimization)", - } -} - -func NoParamReturnArrayAny() []any { - fmt.Println("Go: NoParamReturnArrayAny") - return []any{ - 1.0, - float32(2.0), - "3rd element string (Should be big enough to avoid small string optimization)", - []string{"lolek", "and", "bolek"}, - int32(1), - } -} - -func NoParamReturnArrayVector2() []plugify.Vector2 { - return []plugify.Vector2{ - {1.1, 2.2}, - {-3.3, 4.4}, - {5.5, -6.6}, - {7.7, 8.8}, - {0.0, 0.0}, - } -} - -func NoParamReturnArrayVector3() []plugify.Vector3 { - return []plugify.Vector3{ - {1.1, 2.2, 3.3}, - {-4.4, 5.5, -6.6}, - {7.7, 8.8, 9.9}, - {0.0, 0.0, 0.0}, - {10.1, -11.2, 12.3}, - } -} - -func NoParamReturnArrayVector4() []plugify.Vector4 { - return []plugify.Vector4{ - {1.1, 2.2, 3.3, 4.4}, - {-5.5, 6.6, -7.7, 8.8}, - {9.9, 0.0, -1.1, 2.2}, - {3.3, 4.4, 5.5, 6.6}, - {-7.7, -8.8, 9.9, -10.1}, - } -} - -func NoParamReturnArrayMatrix4x4() []plugify.Matrix4x4 { - return []plugify.Matrix4x4{ - { - M: [4][4]float32{ - {1.0, 0.0, 0.0, 0.0}, - {0.0, 1.0, 0.0, 0.0}, - {0.0, 0.0, 1.0, 0.0}, - {0.0, 0.0, 0.0, 1.0}, - }, - }, - { - M: [4][4]float32{ - {2.0, 3.0, 4.0, 5.0}, - {6.0, 7.0, 8.0, 9.0}, - {10.0, 11.0, 12.0, 13.0}, - {14.0, 15.0, 16.0, 17.0}, - }, - }, - { - M: [4][4]float32{ - {-1.0, -2.0, -3.0, -4.0}, - {-5.0, -6.0, -7.0, -8.0}, - {-9.0, -10.0, -11.0, -12.0}, - {-13.0, -14.0, -15.0, -16.0}, - }, - }, - } -} - -func NoParamReturnVector2() plugify.Vector2 { - fmt.Println("Go: NoParamReturnVector2") - return plugify.Vector2{X: 1, Y: 2} -} - -func NoParamReturnVector3() plugify.Vector3 { - fmt.Println("Go: NoParamReturnVector3") - return plugify.Vector3{X: 1, Y: 2, Z: 3} -} - -func NoParamReturnVector4() plugify.Vector4 { - fmt.Println("Go: NoParamReturnVector4") - return plugify.Vector4{X: 1, Y: 2, Z: 3, W: 4} -} - -func NoParamReturnMatrix4x4() plugify.Matrix4x4 { - fmt.Println("Go: NoParamReturnMatrix4x4") - return plugify.Matrix4x4{ - M: [4][4]float32{ - {1, 2, 3, 4}, - {5, 6, 7, 8}, - {9, 10, 11, 12}, - {13, 14, 15, 16}, - }, - } -} - -func Param1(a int32) { - fmt.Printf("Param1: a = %d\n", a) -} - -func Param2(a int32, b float32) { - fmt.Printf("Param2: a = %d, b = %f\n", a, b) -} - -func Param3(a int32, b float32, c float64) { - fmt.Printf("Param3: a = %d, b = %f, c = %f\n", a, b, c) -} - -func Param4(a int32, b float32, c float64, d plugify.Vector4) { - fmt.Printf("Param4: a = %d, b = %f, c = %f, d = [%f,%f,%f,%f]\n", a, b, c, formatVector4(d)) -} - -func Param5(a int32, b float32, c float64, d plugify.Vector4, e []int64) { - fmt.Printf("Param5: a = %d, b = %f, c = %f, d = [%f,%f,%f,%f], e.size() = %d, e = [", a, b, c, formatVector4(d), len(e)) - for _, elem := range e { - fmt.Printf("%d, ", elem) - } - fmt.Println("]") -} - -func Param6(a int32, b float32, c float64, d plugify.Vector4, e []int64, f int8) { - fmt.Printf("Param6: a = %d, b = %f, c = %f, d = [%f,%f,%f,%f], e.size() = %d, e = [", a, b, c, formatVector4(d), len(e)) - for _, elem := range e { - fmt.Printf("%d, ", elem) - } - fmt.Printf("], f = %c\n", f) -} - -func Param7(a int32, b float32, c float64, d plugify.Vector4, e []int64, f int8, g string) { - fmt.Printf("Param7: a = %d, b = %f, c = %f, d = [%f,%f,%f,%f], e.size() = %d, e = [", a, b, c, formatVector4(d), len(e)) - for _, elem := range e { - fmt.Printf("%d, ", elem) - } - fmt.Printf("], f = %c, g = %s\n", f, g) -} - -func Param8(a int32, b float32, c float64, d plugify.Vector4, e []int64, f int8, g string, h uint16) { - fmt.Printf("Param8: a = %d, b = %f, c = %f, d = [%f,%f,%f,%f], e.size() = %d, e = [", a, b, c, formatVector4(d), len(e)) - for _, elem := range e { - fmt.Printf("%d, ", elem) - } - fmt.Printf("], f = %c, g = %s, h = %f\n", f, g, h) -} - -func Param9(a int32, b float32, c float64, d plugify.Vector4, e []int64, f int8, g string, h uint16, k int16) { - fmt.Printf("Param9: a = %d, b = %f, c = %f, d = [%f,%f,%f,%f], e.size() = %d, e = [", a, b, c, formatVector4(d), len(e)) - for _, elem := range e { - fmt.Printf("%d, ", elem) - } - fmt.Printf("], f = %c, g = %s, h = %f, k = %d\n", f, g, h, k) -} - -func Param10(a int32, b float32, c float64, d plugify.Vector4, e []int64, f int8, g string, h uint16, k int16, l uintptr) { - fmt.Printf("Param10: a = %d, b = %f, c = %f, d = [%f,%f,%f,%f], e.size() = %d, e = [", a, b, c, formatVector4(d), len(e)) - for _, elem := range e { - fmt.Printf("%d, ", elem) - } - fmt.Printf("], f = %c, g = %s, h = %f, k = %d, l = %v\n", f, g, h, k, l) -} - -func ParamRef1(a *int32) { - *a = 42 -} - -func ParamRef2(a *int32, b *float32) { - *a = 10 - *b = 3.14 -} - -func ParamRef3(a *int32, b *float32, c *float64) { - *a = -20 - *b = 2.718 - *c = 3.14159 -} - -func ParamRef4(a *int32, b *float32, c *float64, d *plugify.Vector4) { - *a = 100 - *b = -5.55 - *c = 1.618 - *d = plugify.Vector4{1.0, 2.0, 3.0, 4.0} -} - -func ParamRef5(a *int32, b *float32, c *float64, d *plugify.Vector4, e *[]int64) { - *a = 500 - *b = -10.5 - *c = 2.71828 - *d = plugify.Vector4{-1.0, -2.0, -3.0, -4.0} - *e = []int64{-6, -5, -4, -3, -2, -1, 0, 1} -} - -func ParamRef6(a *int32, b *float32, c *float64, d *plugify.Vector4, e *[]int64, f *int8) { - *a = 750 - *b = 20.0 - *c = 1.23456 - *d = plugify.Vector4{10.0, 20.0, 30.0, 40.0} - *e = []int64{-6, -5, -4} - *f = 'Z' -} - -func ParamRef7(a *int32, b *float32, c *float64, d *plugify.Vector4, e *[]int64, f *int8, g *string) { - *a = -1000 - *b = 3.0 - *c = -1.0 - *d = plugify.Vector4{100.0, 200.0, 300.0, 400.0} - *e = []int64{-6, -5, -4, -3} - *f = 'Y' - *g = "Hello, World!" -} - -func ParamRef8(a *int32, b *float32, c *float64, d *plugify.Vector4, e *[]int64, f *int8, g *string, h *uint16) { - *a = 999 - *b = -7.5 - *c = 0.123456 - *d = plugify.Vector4{-100.0, -200.0, -300.0, -400.0} - *e = []int64{-6, -5, -4, -3, -2, -1} - *f = 'X' - *g = "Goodbye, World!" - *h = 'A' -} - -func ParamRef9(a *int32, b *float32, c *float64, d *plugify.Vector4, e *[]int64, f *int8, g *string, h *uint16, k *int16) { - *a = -1234 - *b = 123.45 - *c = -678.9 - *d = plugify.Vector4{987.65, 432.1, 123.456, 789.123} - *e = []int64{-6, -5, -4, -3, -2, -1, 0, 1, 5, 9} - *f = 'W' - *g = "Testing, 1 2 3" - *h = 'B' - *k = 42 -} - -func ParamRef10(a *int32, b *float32, c *float64, d *plugify.Vector4, e *[]int64, f *int8, g *string, h *uint16, k *int16, l *uintptr) { - *a = 987 - *b = -0.123 - *c = 456.789 - *d = plugify.Vector4{-123.456, 0.987, 654.321, -789.123} - *e = []int64{-6, -5, -4, -3, -2, -1, 0, 1, 5, 9, 4, -7} - *f = 'V' - *g = "Another string" - *h = 'C' - *k = -444 - *l = 0x12345678 -} - -func ParamRefVectors(p1 *[]bool, p2 *[]int8, p3 *[]uint16, p4 *[]int8, p5 *[]int16, p6 *[]int32, p7 *[]int64, p8 *[]uint8, p9 *[]uint16, p10 *[]uint32, p11 *[]uint64, p12 *[]uintptr, p13 *[]float32, p14 *[]float64, p15 *[]string) { - *p1 = []bool{true} - *p2 = []int8{'a', 'b', 'c'} - *p3 = []uint16{'d', 'e', 'f'} - *p4 = []int8{-3, -2, -1, 0, 1, 2, 3} - *p5 = []int16{-4, -3, -2, -1, 0, 1, 2, 3, 4} - *p6 = []int32{-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5} - *p7 = []int64{-6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6} - *p8 = []uint8{0, 1, 2, 3, 4, 5, 6, 7} - *p9 = []uint16{0, 1, 2, 3, 4, 5, 6, 7, 8} - *p10 = []uint32{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} - *p11 = []uint64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10} - *p12 = []uintptr{0, 1, 2} - *p13 = []float32{-12.34, 0.0, 12.34} - *p14 = []float64{-12.345, 0.0, 12.345} - *p15 = []string{"1", "12", "123", "1234", "12345", "123456"} -} - -func ParamAllPrimitives(p1 bool, p2 int8, p3 uint16, p4 int8, p5 int16, p6 int32, p7 int64, p8 uint8, p9 uint16, p10 uint32, p11 uint64, p12 uintptr, p13 float32, p14 float64) int64 { - buffer := fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v%v", p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) - fmt.Println(buffer) - return 56 -} - -func ParamEnum(p1 Example, p2 []Example) int32 { - sum := p1 - for _, e := range p2 { - sum += e - } - return int32(sum) -} - -func ParamEnumRef(p1 *Example, p2 *[]Example) int32 { - *p1 = Forth - *p2 = []Example{First, Second, Third} - sum := *p1 - for _, e := range *p2 { - sum += e - } - return int32(sum) -} - -func ParamVariant(p1 any, p2 []any) { - buffer := fmt.Sprintf("%v%v", p1, p2) - fmt.Println(buffer) -} - -func ParamVariantRef(p1 *any, p2 *[]any) { - *p1 = 'Z' - *p2 = []any{false, 6.28, []float64{1, 2, 3}, uintptr(unsafe.Pointer(nil)), 123456789} -} - -func CallFuncVoid(func_ FuncVoid) { - func_() -} - -func CallFuncBool(func_ FuncBool) bool { - return func_() -} - -func CallFuncChar8(func_ FuncChar8) int8 { - return func_() -} - -func CallFuncChar16(func_ FuncChar16) uint16 { - return func_() -} - -func CallFuncInt8(func_ FuncInt8) int8 { - return func_() -} - -func CallFuncInt16(func_ FuncInt16) int16 { - return func_() -} - -func CallFuncInt32(func_ FuncInt32) int32 { - return func_() -} - -func CallFuncInt64(func_ FuncInt64) int64 { - return func_() -} - -func CallFuncUInt8(func_ FuncUInt8) uint8 { - return func_() -} - -func CallFuncUInt16(func_ FuncUInt16) uint16 { - return func_() -} - -func CallFuncUInt32(func_ FuncUInt32) uint32 { - return func_() -} - -func CallFuncUInt64(func_ FuncUInt64) uint64 { - return func_() -} - -func CallFuncPtr(func_ FuncPtr) uintptr { - return func_() -} - -func CallFuncFloat(func_ FuncFloat) float32 { - return func_() -} - -func CallFuncDouble(func_ FuncDouble) float64 { - return func_() -} - -func CallFuncFunction(func_ FuncFunction) uintptr { - return func_() -} - -func CallFuncString(func_ FuncString) string { - return func_() -} - -func CallFuncAny(func_ FuncAny) any { - return func_() -} - -// Call functions for vector return types -func CallFuncBoolVector(func_ FuncBoolVector) []bool { - result := func_() - return result -} - -func CallFuncChar8Vector(func_ FuncChar8Vector) []int8 { - result := func_() - return result -} - -func CallFuncChar16Vector(func_ FuncChar16Vector) []uint16 { - result := func_() - return result -} - -func CallFuncInt8Vector(func_ FuncInt8Vector) []int8 { - result := func_() - return result -} - -func CallFuncInt16Vector(func_ FuncInt16Vector) []int16 { - result := func_() - return result -} - -func CallFuncInt32Vector(func_ FuncInt32Vector) []int32 { - result := func_() - return result -} - -func CallFuncInt64Vector(func_ FuncInt64Vector) []int64 { - result := func_() - return result -} - -func CallFuncUInt8Vector(func_ FuncUInt8Vector) []uint8 { - result := func_() - return result -} - -func CallFuncUInt16Vector(func_ FuncUInt16Vector) []uint16 { - result := func_() - return result -} - -func CallFuncUInt32Vector(func_ FuncUInt32Vector) []uint32 { - result := func_() - return result -} - -func CallFuncUInt64Vector(func_ FuncUInt64Vector) []uint64 { - result := func_() - return result -} - -func CallFuncPtrVector(func_ FuncPtrVector) []uintptr { - result := func_() - return result -} - -func CallFuncFloatVector(func_ FuncFloatVector) []float32 { - result := func_() - return result -} - -func CallFuncDoubleVector(func_ FuncDoubleVector) []float64 { - result := func_() - return result -} - -func CallFuncStringVector(func_ FuncStringVector) []string { - result := func_() - return result -} - -func CallFuncAnyVector(func_ FuncAnyVector) []any { - result := func_() - return result -} - -func CallFuncVec2Vector(func_ FuncVec2Vector) []plugify.Vector2 { - result := func_() - return result -} - -func CallFuncVec3Vector(func_ FuncVec3Vector) []plugify.Vector3 { - result := func_() - return result -} - -func CallFuncVec4Vector(func_ FuncVec4Vector) []plugify.Vector4 { - result := func_() - return result -} - -func CallFuncMat4x4Vector(func_ FuncMat4x4Vector) []plugify.Matrix4x4 { - result := func_() - return result -} - -func CallFuncVec2(func_ FuncVec2) plugify.Vector2 { - result := func_() - return result -} - -func CallFuncVec3(func_ FuncVec3) plugify.Vector3 { - result := func_() - return result -} - -func CallFuncVec4(func_ FuncVec4) plugify.Vector4 { - result := func_() - return result -} - -func CallFuncMat4x4(func_ FuncMat4x4) plugify.Matrix4x4 { - result := func_() - return result -} - -func CallFunc1(func_ Func1) int32 { - vec := plugify.Vector3{4.5, 5.6, 6.7} - return func_(&vec) -} - -func CallFunc2(func_ Func2) int8 { - f := float32(2.71) - i64 := int64(200) - return func_(f, i64) -} - -func CallFunc3(func_ Func3) { - ptr := uintptr(12345) - vec4 := plugify.Vector4{7.8, 8.9, 9.1, 10.2} - str := "RandomString" - func_(ptr, &vec4, str) -} - -func CallFunc4(func_ Func4) plugify.Vector4 { - b := false - u32 := int32(42) - ch16 := uint16('B') - mat := plugify.Matrix4x4Identity() - return func_(b, u32, ch16, &mat) -} - -func CallFunc5(func_ Func5) bool { - i8 := int8(10) - vec2 := plugify.Vector2{3.4, 5.6} - ptr := uintptr(67890) - d := 1.618 - vec64 := []uint64{4, 5, 6} - return func_(i8, &vec2, ptr, d, vec64) -} - -func CallFunc6(func_ Func6) int64 { - str := "AnotherString" - f := float32(4.56) - vecF := []float32{4.0, 5.0, 6.0} - i16 := int16(30) - vecU8 := []uint8{3, 4, 5} - ptr := uintptr(24680) - return func_(str, f, vecF, i16, vecU8, ptr) -} - -func CallFunc7(func_ Func7) float64 { - vecC := []int8{'X', 'Y', 'Z'} - u16 := uint16(20) - ch16 := uint16('C') - vecU32 := []uint32{4, 5, 6} - vec4 := plugify.Vector4{4.5, 5.6, 6.7, 7.8} - b := false - u64 := uint64(200) - return func_(vecC, u16, ch16, vecU32, &vec4, b, u64) -} - -func CallFunc8(func_ Func8) plugify.Matrix4x4 { - vec3 := plugify.Vector3{4.0, 5.0, 6.0} - vecU32 := []uint32{4, 5, 6} - i16 := int16(30) - b := false - vec4 := plugify.Vector4{4.5, 5.6, 6.7, 7.8} - vecC16 := []uint16{'D', 'E'} - ch16 := uint16('B') - i32 := int32(50) - return func_(&vec3, vecU32, i16, b, &vec4, vecC16, ch16, i32) -} - -func CallFunc9(func_ Func9) { - f := float32(2.71) - vec2 := plugify.Vector2{3.4, 5.6} - vecI8 := []int8{4, 5, 6} - u64 := uint64(250) - b := false - str := "Random" - vec4 := plugify.Vector4{4.5, 5.6, 6.7, 7.8} - i16 := int16(30) - ptr := uintptr(13579) - func_(f, &vec2, vecI8, u64, b, str, &vec4, i16, ptr) -} - -func CallFunc10(func_ Func10) uint32 { - vec4 := plugify.Vector4{5.6, 7.8, 8.9, 9.0} - mat := plugify.Matrix4x4Identity() - vecU32 := []uint32{4, 5, 6} - u64 := uint64(150) - vecC := []int8{'X', 'Y', 'Z'} - i32 := int32(60) - b := false - vec2 := plugify.Vector2{3.4, 5.6} - i64 := int64(75) - d := 2.71 - return func_(&vec4, &mat, vecU32, u64, vecC, i32, b, &vec2, i64, d) -} - -func CallFunc11(func_ Func11) uintptr { - vecB := []bool{false, true, false} - ch16 := uint16('C') - u8 := uint8(10) - d := 2.71 - vec3 := plugify.Vector3{4.0, 5.0, 6.0} - vecI8 := []int8{3, 4, 5} - i64 := int64(150) - u16 := uint16(20) - f := float32(2.0) - vec2 := plugify.Vector2{4.5, 6.7} - u32 := uint32(30) - return func_(vecB, ch16, u8, d, &vec3, vecI8, i64, u16, f, &vec2, u32) -} - -func CallFunc12(func_ Func12) bool { - ptr := uintptr(98765) - vecD := []float64{4.0, 5.0, 6.0} - u32 := uint32(30) - d := 1.41 - b := false - i32 := int32(25) - i8 := int8(10) - u64 := uint64(300) - f := float32(2.72) - vecPtr := []uintptr{2, 3, 4} - i64 := int64(200) - ch := int8('B') - return func_(ptr, vecD, u32, d, b, i32, i8, u64, f, vecPtr, i64, ch) -} - -func CallFunc13(func_ Func13) string { - i64 := int64(75) - vecC := []int8{'D', 'E', 'F'} - u16 := uint16(20) - f := float32(2.71) - vecB := []bool{false, true, false} - vec4 := plugify.Vector4{5.6, 7.8, 9.0, 10.1} - str := "RandomString" - i32 := int32(30) - vec3 := plugify.Vector3{4.0, 5.0, 6.0} - ptr := uintptr(13579) - vec2 := plugify.Vector2{4.5, 6.7} - vecU8 := []uint8{2, 3, 4} - i16 := int16(20) - return func_(i64, vecC, u16, f, vecB, &vec4, str, i32, &vec3, ptr, &vec2, vecU8, i16) -} - -func CallFunc14(func_ Func14) []string { - vecC := []int8{'D', 'E', 'F'} - vecU32 := []uint32{4, 5, 6} - mat := plugify.Matrix4x4Identity() - b := false - ch16 := uint16('B') - i32 := int32(25) - vecF := []float32{4.0, 5.0, 6.0} - u16 := uint16(30) - vecU8 := []uint8{3, 4, 5} - i8 := int8(10) - vec3 := plugify.Vector3{4.0, 5.0, 6.0} - vec4 := plugify.Vector4{5.6, 7.8, 9.0, 10.1} - d := 2.72 - ptr := uintptr(54321) - return func_(vecC, vecU32, &mat, b, ch16, i32, vecF, u16, vecU8, i8, &vec3, &vec4, d, ptr) -} - -func CallFunc15(func_ Func15) int16 { - vecI16 := []int16{4, 5, 6} - mat := plugify.Matrix4x4Identity() - vec4 := plugify.Vector4{7.8, 8.9, 9.0, 10.1} - ptr := uintptr(12345) - u64 := uint64(200) - vecU32 := []uint32{5, 6, 7} - b := false - f := float32(3.14) - vecC16 := []uint16{'D', 'E'} - u8 := uint8(6) - i32 := int32(25) - vec2 := plugify.Vector2{5.6, 7.8} - u16 := uint16(40) - d := 2.71 - vecU8 := []uint8{1, 3, 5} - return func_(vecI16, &mat, &vec4, ptr, u64, vecU32, b, f, vecC16, u8, i32, &vec2, u16, d, vecU8) -} - -func CallFunc16(func_ Func16) uintptr { - vecB := []bool{true, true, false} - i16 := int16(20) - vecI8 := []int8{2, 3, 4} - vec4 := plugify.Vector4{7.8, 8.9, 9.0, 10.1} - mat := plugify.Matrix4x4Identity() - vec2 := plugify.Vector2{5.6, 7.8} - vecU64 := []uint64{5, 6, 7} - vecC := []int8{'D', 'E', 'F'} - str := "DifferentString" - i64 := int64(300) - vecU32 := []uint32{6, 7, 8} - vec3 := plugify.Vector3{5.0, 6.0, 7.0} - f := float32(3.14) - d := 2.718 - i8 := int8(6) - u16 := uint16(30) - return func_(vecB, i16, vecI8, &vec4, &mat, &vec2, vecU64, vecC, str, i64, vecU32, &vec3, f, d, i8, u16) -} - -// Implement the functions -func CallFunc17(func_ Func17) string { - i32 := int32(42) - func_(&i32) - return fmt.Sprintf("%d", i32) -} - -func CallFunc18(func_ Func18) string { - i8 := int8(9) - i16 := int16(25) - ret := func_(&i8, &i16) - return fmt.Sprintf("%s|%d|%d", formatVector2(ret), i8, i16) -} - -func CallFunc19(func_ Func19) string { - u32 := uint32(75) - vec3 := plugify.Vector3{4.0, 5.0, 6.0} - vecU32 := []uint32{4, 5, 6} - func_(&u32, &vec3, &vecU32) - return fmt.Sprintf("%d|%v|%v", u32, formatVector3(vec3), formatArray(vecU32)) -} - -func CallFunc20(func_ Func20) string { - ch16 := uint16('Z') - vec4 := plugify.Vector4{5.0, 6.0, 7.0, 8.0} - vecU64 := []uint64{4, 5, 6} - ch := int8('X') - ret := func_(&ch16, &vec4, &vecU64, &ch) - return fmt.Sprintf("%d|%d|%v|%v|%c", ret, ch16, formatVector4(vec4), formatArray(vecU64), ch) -} - -func CallFunc21(func_ Func21) string { - mat := plugify.Matrix4x4{} - vecI32 := []int32{4, 5, 6} - vec2 := plugify.Vector2{3.0, 4.0} - b := false - d := 6.28 - ret := func_(&mat, &vecI32, &vec2, &b, &d) - return fmt.Sprintf("%v|%v|%v|%v|%t|%v", formatFlt32(ret), formatMatrix4x4(mat), formatArray(vecI32), formatVector2(vec2), b, formatFlt64(d)) -} - -func CallFunc22(func_ Func22) string { - ptr := uintptr(1) - u32 := uint32(20) - vecD := []float64{4.0, 5.0, 6.0} - i16 := int16(15) - str := "Updated Test" - vec4 := plugify.Vector4{5.0, 6.0, 7.0, 8.0} - ret := func_(&ptr, &u32, &vecD, &i16, &str, &vec4) - return fmt.Sprintf("%d|0x%x|%d|%v|%d|%v|%v", ret, ptr, u32, formatArrayFmt(vecD, formatFlt64), i16, str, formatVector4(vec4)) -} - -func CallFunc23(func_ Func23) string { - u64 := uint64(200) - vec2 := plugify.Vector2{3.0, 4.0} - vecI16 := []int16{4, 5, 6} - ch16 := uint16('Y') - f := float32(2.34) - i8 := int8(10) - vecU8 := []uint8{3, 4, 5} - func_(&u64, &vec2, &vecI16, &ch16, &f, &i8, &vecU8) - return fmt.Sprintf("%d|%v|%v|%d|%v|%d|%v", u64, formatVector2(vec2), formatArray(vecI16), ch16, formatFlt32(f), i8, formatArray(vecU8)) -} - -func CallFunc24(func_ Func24) string { - vecC := []int8{'D', 'E', 'F'} - i64 := int64(100) - vecU8 := []uint8{3, 4, 5} - vec4 := plugify.Vector4{5.0, 6.0, 7.0, 8.0} - u64 := uint64(200) - vecPtr := []uintptr{3, 4, 5} - d := 6.28 - vecV2 := []uintptr{4, 5, 6, 7} - ret := func_(&vecC, &i64, &vecU8, &vec4, &u64, &vecPtr, &d, &vecV2) - return fmt.Sprintf("%v|%v|%d|%v|%v|%d|%v|%v|%v", formatMatrix4x4(ret), formatArrayFmt(vecC, formatChr), i64, formatArray(vecU8), formatVector4(vec4), u64, formatArrayFmt(vecPtr, formatPtr), formatFlt64(d), formatArrayFmt(vecV2, formatPtr)) -} - -func CallFunc25(func_ Func25) string { - i32 := int32(50) - vecPtr := []uintptr{3, 4, 5} - b := false - u8 := uint8(10) - str := "Updated Test String" - vec3 := plugify.Vector3{4.0, 5.0, 6.0} - i64 := int64(100) - vec4 := plugify.Vector4{5.0, 6.0, 7.0, 8.0} - u16 := uint16(20) - ret := func_(&i32, &vecPtr, &b, &u8, &str, &vec3, &i64, &vec4, &u16) - return fmt.Sprintf("%v|%d|%v|%t|%d|%v|%v|%d|%v|%d", formatFlt64(ret), i32, formatArrayFmt(vecPtr, formatPtr), b, u8, str, formatVector3(vec3), i64, formatVector4(vec4), u16) -} - -func CallFunc26(func_ Func26) string { - ch16 := uint16('B') - vec2 := plugify.Vector2{3.0, 4.0} - mat := plugify.Matrix4x4{} - vecF := []float32{4.0, 5.0, 6.0} - i16 := int16(20) - u64 := uint64(200) - u32 := uint32(20) - vecU16 := []uint16{3, 4, 5} - ptr := uintptr(0xDEADBEAFDEADBEAF) - b := false - ret := func_(&ch16, &vec2, &mat, &vecF, &i16, &u64, &u32, &vecU16, &ptr, &b) - return fmt.Sprintf("%c|%d|%v|%v|%v|%d|%d|%v|0x%x|%t", ret, ch16, formatVector2(vec2), formatMatrix4x4(mat), formatArrayFmt(vecF, formatFlt32), u64, u32, formatArray(vecU16), ptr, b) -} - -func CallFunc27(func_ Func27) string { - f := float32(2.56) - vec3 := plugify.Vector3{4.0, 5.0, 6.0} - ptr := uintptr(0) - vec2 := plugify.Vector2{3.0, 4.0} - vecI16 := []int16{4, 5, 6} - mat := plugify.Matrix4x4{} - b := false - vec4 := plugify.Vector4{5.0, 6.0, 7.0, 8.0} - i8 := int8(10) - i32 := int32(40) - vecU8 := []uint8{3, 4, 5} - ret := func_(&f, &vec3, &ptr, &vec2, &vecI16, &mat, &b, &vec4, &i8, &i32, &vecU8) - return fmt.Sprintf("%d|%v|%v|0x%x|%v|%v|%v|%t|%v|%d|%d|%v", ret, formatFlt32(f), formatVector3(vec3), ptr, formatVector2(vec2), formatArray(vecI16), formatMatrix4x4(mat), b, formatVector4(vec4), i8, i32, formatArray(vecU8)) -} - -func CallFunc28(func_ Func28) string { - ptr := uintptr(1) - u16 := uint16(20) - vecU32 := []uint32{4, 5, 6} - mat := plugify.Matrix4x4{} - f := float32(2.71) - vec4 := plugify.Vector4{5.0, 6.0, 7.0, 8.0} - str := "New example string" - vecU64 := []uint64{400, 500, 600} - i64 := int64(987654321) - b := false - vec3 := plugify.Vector3{4.0, 5.0, 6.0} - vecF := []float32{4.0, 5.0, 6.0} - ret := func_(&ptr, &u16, &vecU32, &mat, &f, &vec4, &str, &vecU64, &i64, &b, &vec3, &vecF) - return fmt.Sprintf("%v|0x%x|%d|%v|%v|%v|%v|%v|%v|%d|%t|%v|%v", ret, ptr, u16, formatArray(vecU32), formatMatrix4x4(mat), formatFlt32(f), formatVector4(vec4), str, formatArray(vecU64), i64, b, formatVector3(vec3), formatArrayFmt(vecF, formatFlt32)) -} - -func CallFunc29(func_ Func29) string { - vec4 := plugify.Vector4{2.0, 3.0, 4.0, 5.0} - i32 := int32(99) - vecI8 := []int8{4, 5, 6} - d := float64(2.71) - b := false - i8 := int8(10) - vecU16 := []uint16{4, 5, 6} - f := float32(3.21) - str := "Yet another example string" - mat := plugify.Matrix4x4{} - u64 := uint64(200) - vec3 := plugify.Vector3{5.0, 6.0, 7.0} - vecI64 := []int64{2000, 3000, 4000} - ret := func_(&vec4, &i32, &vecI8, &d, &b, &i8, &vecU16, &f, &str, &mat, &u64, &vec3, &vecI64) - return fmt.Sprintf("%v|%v|%d|%v|%v|%t|%d|%v|%v|%s|%v|%d|%v|%v", formatArrayFmt(ret, formatStr), formatVector4(vec4), i32, formatArray(vecI8), formatFlt64(d), b, i8, formatArray(vecU16), formatFlt32(f), str, formatMatrix4x4(mat), u64, formatVector3(vec3), formatArray(vecI64)) -} - -func CallFunc30(func_ Func30) string { - ptr := uintptr(1) - vec4 := plugify.Vector4{2.0, 3.0, 4.0, 5.0} - i64 := int64(987654321) - vecU32 := []uint32{4, 5, 6} - b := false - str := "Updated String for Func30" - vec3 := plugify.Vector3{5.0, 6.0, 7.0} - vecU8 := []uint8{1, 2, 3} - f := float32(5.67) - vec2 := plugify.Vector2{3.0, 4.0} - mat := plugify.Matrix4x4{} - i8 := int8(10) - vecF := []float32{4.0, 5.0, 6.0} - d := float64(8.90) - ret := func_(&ptr, &vec4, &i64, &vecU32, &b, &str, &vec3, &vecU8, &f, &vec2, &mat, &i8, &vecF, &d) - return fmt.Sprintf("%d|0x%x|%v|%d|%v|%t|%s|%v|%v|%v|%v|%v|%d|%v|%v", ret, ptr, formatVector4(vec4), i64, formatArray(vecU32), b, str, formatVector3(vec3), formatArray(vecU8), formatFlt32(f), formatVector2(vec2), formatMatrix4x4(mat), i8, formatArrayFmt(vecF, formatFlt32), formatFlt64(d)) -} - -func CallFunc31(func_ Func31) string { - ch := int8('B') - u32 := uint32(200) - vecU64 := []uint64{4, 5, 6} - vec4 := plugify.Vector4{2.0, 3.0, 4.0, 5.0} - str := "Updated String for Func31" - b := true - i64 := int64(987654321) - vec2 := plugify.Vector2{3.0, 4.0} - i8 := int8(10) - u16 := uint16(20) - vecI16 := []int16{4, 5, 6} - mat := plugify.Matrix4x4{} - vec3 := plugify.Vector3{4.0, 5.0, 6.0} - f := float32(5.67) - vecD := []float64{4.0, 5.0, 6.0} - ret := func_(&ch, &u32, &vecU64, &vec4, &str, &b, &i64, &vec2, &i8, &u16, &vecI16, &mat, &vec3, &f, &vecD) - return fmt.Sprintf("%v|%c|%d|%v|%v|%s|%t|%d|%v|%d|%d|%v|%v|%v|%v|%v", formatVector3(ret), ch, u32, formatArray(vecU64), formatVector4(vec4), str, b, i64, formatVector2(vec2), i8, u16, formatArray(vecI16), formatMatrix4x4(mat), formatVector3(vec3), formatFlt32(f), formatArrayFmt(vecD, formatFlt64)) -} - -func CallFunc32(func_ Func32) string { - i32 := int32(30) - u16 := uint16(20) - vecI8 := []int8{4, 5, 6} - vec4 := plugify.Vector4{2.0, 3.0, 4.0, 5.0} - ptr := uintptr(1) - vecU32 := []uint32{4, 5, 6} - mat := plugify.Matrix4x4{} - u64 := uint64(200) - str := "Updated String for Func32" - i64 := int64(987654321) - vec2 := plugify.Vector2{3.0, 4.0} - vecI8_2 := []int8{7, 8, 9} - b := false - vec3 := plugify.Vector3{4.0, 5.0, 6.0} - u8 := uint8(128) - vecC16 := []uint16{'D', 'E', 'F'} - - func_(&i32, &u16, &vecI8, &vec4, &ptr, &vecU32, &mat, &u64, &str, &i64, &vec2, &vecI8_2, &b, &vec3, &u8, &vecC16) - return fmt.Sprintf("%d|%d|%v|%v|0x%x|%v|%v|%d|%s|%d|%v|%v|%t|%v|%d|%v", i32, u16, formatArray(vecI8), formatVector4(vec4), ptr, formatArray(vecU32), formatMatrix4x4(mat), u64, str, i64, formatVector2(vec2), formatArray(vecI8_2), b, formatVector3(vec3), u8, formatArray(vecC16)) -} - -func CallFunc33(func_ Func33) string { - var variant any - variant = int32(30) - func_(&variant) - return fmt.Sprintf("%v", variant) -} - -func CallFuncEnum(func_ FuncEnum) string { - p1 := Forth - p2 := []Example{} - ret := func_(p1, &p2) - retStr := fmt.Sprintf("%v|%v", formatArray(ret), formatArray(p2)) - return retStr -} - -func main() {} - -// -// -// -// -// Reverse staff - -// Define the function implementations -func ReverseNoParamReturnVoid() string { - cross_call_master.NoParamReturnVoidCallback() - return "" -} - -func ReverseNoParamReturnBool() string { - result := cross_call_master.NoParamReturnBoolCallback() - return formatBool(result) -} - -func ReverseNoParamReturnChar8() string { - result := cross_call_master.NoParamReturnChar8Callback() - return fmt.Sprintf("%c", result) -} - -func ReverseNoParamReturnChar16() string { - result := cross_call_master.NoParamReturnChar16Callback() - return fmt.Sprintf("%d", result) -} - -func ReverseNoParamReturnInt8() string { - result := cross_call_master.NoParamReturnInt8Callback() - return fmt.Sprintf("%d", result) -} - -func ReverseNoParamReturnInt16() string { - result := cross_call_master.NoParamReturnInt16Callback() - return fmt.Sprintf("%d", result) -} - -func ReverseNoParamReturnInt32() string { - result := cross_call_master.NoParamReturnInt32Callback() - return fmt.Sprintf("%d", result) -} - -func ReverseNoParamReturnInt64() string { - result := cross_call_master.NoParamReturnInt64Callback() - return fmt.Sprintf("%d", result) -} - -func ReverseNoParamReturnUInt8() string { - result := cross_call_master.NoParamReturnUInt8Callback() - return fmt.Sprintf("%d", result) -} - -func ReverseNoParamReturnUInt16() string { - result := cross_call_master.NoParamReturnUInt16Callback() - return fmt.Sprintf("%d", result) -} - -func ReverseNoParamReturnUInt32() string { - result := cross_call_master.NoParamReturnUInt32Callback() - return fmt.Sprintf("%d", result) -} - -func ReverseNoParamReturnUInt64() string { - result := cross_call_master.NoParamReturnUInt64Callback() - return fmt.Sprintf("%d", result) -} - -func ReverseNoParamReturnPointer() string { - result := cross_call_master.NoParamReturnPointerCallback() - return fmt.Sprintf("0x%x", result) -} - -func ReverseNoParamReturnFloat() string { - result := cross_call_master.NoParamReturnFloatCallback() - return fmt.Sprintf("%v", formatFlt32(result)) -} - -func ReverseNoParamReturnDouble() string { - result := cross_call_master.NoParamReturnDoubleCallback() - return fmt.Sprintf("%v", formatFlt64(result)) -} - -func ReverseNoParamReturnFunction() string { - result := cross_call_master.NoParamReturnFunctionCallback() - return fmt.Sprintf("%d", result()) -} - -func ReverseNoParamReturnString() string { - result := cross_call_master.NoParamReturnStringCallback() - return result -} - -func ReverseNoParamReturnAny() string { - result := cross_call_master.NoParamReturnAnyCallback() - return fmt.Sprintf("%v", result) -} - -func ReverseNoParamReturnArrayBool() string { - result := cross_call_master.NoParamReturnArrayBoolCallback() - return formatArrayFmt(result, formatBool) -} - -func ReverseNoParamReturnArrayChar8() string { - result := cross_call_master.NoParamReturnArrayChar8Callback() - return formatArrayFmt(result, formatChr) -} - -func ReverseNoParamReturnArrayChar16() string { - result := cross_call_master.NoParamReturnArrayChar16Callback() - return formatArray(result) -} - -func ReverseNoParamReturnArrayInt8() string { - result := cross_call_master.NoParamReturnArrayInt8Callback() - return formatArray(result) -} - -func ReverseNoParamReturnArrayInt16() string { - result := cross_call_master.NoParamReturnArrayInt16Callback() - return formatArray(result) -} - -func ReverseNoParamReturnArrayInt32() string { - result := cross_call_master.NoParamReturnArrayInt32Callback() - return formatArray(result) -} - -func ReverseNoParamReturnArrayInt64() string { - result := cross_call_master.NoParamReturnArrayInt64Callback() - return formatArray(result) -} - -func ReverseNoParamReturnArrayUInt8() string { - result := cross_call_master.NoParamReturnArrayUInt8Callback() - return formatArray(result) -} - -func ReverseNoParamReturnArrayUInt16() string { - result := cross_call_master.NoParamReturnArrayUInt16Callback() - return formatArray(result) -} - -func ReverseNoParamReturnArrayUInt32() string { - result := cross_call_master.NoParamReturnArrayUInt32Callback() - return formatArray(result) -} - -func ReverseNoParamReturnArrayUInt64() string { - result := cross_call_master.NoParamReturnArrayUInt64Callback() - return formatArray(result) -} - -func ReverseNoParamReturnArrayPointer() string { - result := cross_call_master.NoParamReturnArrayPointerCallback() - return formatArrayFmt(result, formatPtr) -} - -func ReverseNoParamReturnArrayFloat() string { - result := cross_call_master.NoParamReturnArrayFloatCallback() - return formatArrayFmt(result, formatFlt32) -} - -func ReverseNoParamReturnArrayDouble() string { - result := cross_call_master.NoParamReturnArrayDoubleCallback() - return formatArrayFmt(result, formatFlt64) -} - -func ReverseNoParamReturnArrayString() string { - result := cross_call_master.NoParamReturnArrayStringCallback() - return formatArrayFmt(result, formatStr) -} - -func ReverseNoParamReturnArrayAny() string { - result := cross_call_master.NoParamReturnArrayAnyCallback() - return formatArrayFmt(result, formatAny) -} - -func ReverseNoParamReturnVector2() string { - result := cross_call_master.NoParamReturnVector2Callback() - return formatVector2(result) -} - -func ReverseNoParamReturnVector3() string { - result := cross_call_master.NoParamReturnVector3Callback() - return formatVector3(result) -} - -func ReverseNoParamReturnVector4() string { - result := cross_call_master.NoParamReturnVector4Callback() - return formatVector4(result) -} - -func ReverseNoParamReturnMatrix4x4() string { - result := cross_call_master.NoParamReturnMatrix4x4Callback() - return formatMatrix4x4(result) -} - -func ReverseParam1() string { - cross_call_master.Param1Callback(999) - return "" -} - -func ReverseParam2() string { - cross_call_master.Param2Callback(888, 9.9) - return "" -} - -func ReverseParam3() string { - cross_call_master.Param3Callback(777, 8.8, 9.8765) - return "" -} - -func ReverseParam4() string { - cross_call_master.Param4Callback(666, 7.7, 8.7659, plugify.Vector4{100.1, 200.2, 300.3, 400.4}) - return "" -} - -func ReverseParam5() string { - cross_call_master.Param5Callback(555, 6.6, 7.6598, plugify.Vector4{-105.1, -205.2, -305.3, -405.4}, []int64{}) - return "" -} - -func ReverseParam6() string { - cross_call_master.Param6Callback(444, 5.5, 6.5987, plugify.Vector4{110.1, 210.2, 310.3, 410.4}, []int64{90000, -100, 20000}, 'A') - return "" -} - -func ReverseParam7() string { - cross_call_master.Param7Callback(333, 4.4, 5.9876, plugify.Vector4{-115.1, -215.2, -315.3, -415.4}, []int64{800000, 30000, -4000000}, 'B', "red gold") - return "" -} - -func ReverseParam8() string { - cross_call_master.Param8Callback(222, 3.3, 1.2345, plugify.Vector4{120.1, 220.2, 320.3, 420.4}, []int64{7000000, 5000000, -600000000}, 'C', "blue ice", 'Z') - return "" -} - -func ReverseParam9() string { - cross_call_master.Param9Callback(111, 2.2, 5.1234, plugify.Vector4{-125.1, -225.2, -325.3, -425.4}, []int64{60000000, -700000000, 80000000000}, 'D', "pink metal", 'Y', -100) - return "" -} - -func ReverseParam10() string { - cross_call_master.Param10Callback(1234, 1.1, 4.5123, plugify.Vector4{130.1, 230.2, 330.3, 430.4}, []int64{500000000, 90000000000, 1000000000000}, 'E', "green wood", 'X', -200, 0xabeba) - return "" -} - -func ReverseParamRef1() string { - a := int32(0) - cross_call_master.ParamRef1Callback(&a) - return strconv.Itoa(int(a)) -} - -func ReverseParamRef2() string { - a, b := int32(0), float32(0) - cross_call_master.ParamRef2Callback(&a, &b) - return fmt.Sprintf("%d|%.1f", a, b) -} - -func ReverseParamRef3() string { - a, b, c := int32(0), float32(0), float64(0) - cross_call_master.ParamRef3Callback(&a, &b, &c) - return fmt.Sprintf("%d|%.1f|%.5f", a, b, c) -} - -func ReverseParamRef4() string { - a, b, c := int32(0), float32(0), float64(0) - d := plugify.Vector4{} - cross_call_master.ParamRef4Callback(&a, &b, &c, &d) - return fmt.Sprintf("%d|%.1f|%.5f|%v", a, b, c, formatVector4(d)) -} - -func ReverseParamRef5() string { - a, b, c := int32(0), float32(0), float64(0) - d := plugify.Vector4{} - e := []int64{} - cross_call_master.ParamRef5Callback(&a, &b, &c, &d, &e) - return fmt.Sprintf("%d|%.1f|%.5f|%v|%s", a, b, c, formatVector4(d), formatArray(e)) -} - -func ReverseParamRef6() string { - a, b, c := int32(0), float32(0), float64(0) - d := plugify.Vector4{} - e := []int64{} - f := int8(0) - cross_call_master.ParamRef6Callback(&a, &b, &c, &d, &e, &f) - return fmt.Sprintf("%d|%.1f|%.5f|%v|%s|%d", a, b, c, formatVector4(d), formatArray(e), f) -} - -func ReverseParamRef7() string { - a, b, c := int32(0), float32(0), float64(0) - d := plugify.Vector4{} - e := []int64{} - f := int8(0) - g := "" - cross_call_master.ParamRef7Callback(&a, &b, &c, &d, &e, &f, &g) - return fmt.Sprintf("%d|%.1f|%.5f|%v|%s|%d|%s", a, b, c, formatVector4(d), formatArray(e), f, g) -} - -func ReverseParamRef8() string { - a, b, c := int32(0), float32(0), float64(0) - d := plugify.Vector4{} - e := []int64{} - f := int8(0) - g := "" - h := uint16(0) - cross_call_master.ParamRef8Callback(&a, &b, &c, &d, &e, &f, &g, &h) - return fmt.Sprintf("%d|%.1f|%.5f|%v|%s|%d|%s|%d", a, b, c, formatVector4(d), formatArray(e), f, g, h) -} - -func ReverseParamRef9() string { - a, b, c := int32(0), float32(0), float64(0) - d := plugify.Vector4{} - e := []int64{} - f := int8(0) - g := "" - h := uint16(0) - k := int16(0) - cross_call_master.ParamRef9Callback(&a, &b, &c, &d, &e, &f, &g, &h, &k) - return fmt.Sprintf("%d|%.1f|%.5f|%v|%s|%d|%s|%d|%d", a, b, c, formatVector4(d), formatArray(e), f, g, h, k) -} - -func ReverseParamRef10() string { - a, b, c := int32(0), float32(0), float64(0) - d := plugify.Vector4{} - e := []int64{} - f := int8(0) - g := "" - h := uint16(0) - k := int16(0) - l := uintptr(0) - cross_call_master.ParamRef10Callback(&a, &b, &c, &d, &e, &f, &g, &h, &k, &l) - return fmt.Sprintf("%d|%.1f|%.5f|%v|%s|%d|%s|%d|%d|0x%x", a, b, c, formatVector4(d), formatArray(e), f, g, h, k, l) -} - -func formatBool(b bool) string { - if b { - return "true" - } - return "false" -} - -func formatPtr(p uintptr) string { - return fmt.Sprintf("0x%x", p) -} - -func formatChr(c int8) string { - return fmt.Sprintf("%c", c) -} - -func formatStr(s string) string { - return fmt.Sprintf("'%s'", s) -} - -func formatFlt32(d float32) string { - s := fmt.Sprintf("%.3f", d) - s = strings.TrimRight(s, "0") - s = strings.TrimRight(s, ".") - return s -} - -func formatFlt64(d float64) string { - s := fmt.Sprintf("%.6f", d) - s = strings.TrimRight(s, "0") - s = strings.TrimRight(s, ".") - return s -} - -func formatAny(a any) string { - return fmt.Sprintf("%v", a) -} - -func formatVector2(t plugify.Vector2) string { - return fmt.Sprintf("{%s, %s}", formatFlt32(t.X), formatFlt32(t.Y)) -} - -func formatVector3(t plugify.Vector3) string { - return fmt.Sprintf("{%s, %s, %s}", formatFlt32(t.X), formatFlt32(t.Y), formatFlt32(t.Z)) -} - -func formatVector4(t plugify.Vector4) string { - return fmt.Sprintf("{%s, %s, %s, %s}", formatFlt32(t.X), formatFlt32(t.Y), formatFlt32(t.Z), formatFlt32(t.W)) -} - -func formatMatrix4x4(t plugify.Matrix4x4) string { - formattedRow1 := fmt.Sprintf("{%s, %s, %s, %s}", formatFlt32(t.M[0][0]), formatFlt32(t.M[0][1]), formatFlt32(t.M[0][2]), formatFlt32(t.M[0][3])) - formattedRow2 := fmt.Sprintf("{%s, %s, %s, %s}", formatFlt32(t.M[1][0]), formatFlt32(t.M[1][1]), formatFlt32(t.M[1][2]), formatFlt32(t.M[1][3])) - formattedRow3 := fmt.Sprintf("{%s, %s, %s, %s}", formatFlt32(t.M[2][0]), formatFlt32(t.M[2][1]), formatFlt32(t.M[2][2]), formatFlt32(t.M[2][3])) - formattedRow4 := fmt.Sprintf("{%s, %s, %s, %s}", formatFlt32(t.M[3][0]), formatFlt32(t.M[3][1]), formatFlt32(t.M[3][2]), formatFlt32(t.M[3][3])) - return fmt.Sprintf("{%s, %s, %s, %s}", formattedRow1, formattedRow2, formattedRow3, formattedRow4) -} - -func formatArray[T any](arr []T) string { - if len(arr) == 0 { - return "{}" - } - - str := "{" - for _, v := range arr { - str += fmt.Sprintf("%v, ", v) - } - if len(str) > 0 { - str = str[:len(str)-2] + "}" - } - return str -} - -func formatArrayFmt[T any](arr []T, format func(T) string) string { - if len(arr) == 0 { - return "{}" - } - - str := "{" - for _, v := range arr { - str += fmt.Sprintf("%s, ", format(v)) - } - if len(str) > 0 { - str = str[:len(str)-2] + "}" - } - return str -} - -func ReverseParamRefVectors() string { - p1 := []bool{} - p2 := []int8{} - p3 := []uint16{} - p4 := []int8{} - p5 := []int16{} - p6 := []int32{} - p7 := []int64{} - p8 := []uint8{} - p9 := []uint16{} - p10 := []uint32{} - p11 := []uint64{} - p12 := []uintptr{} - p13 := []float32{} - p14 := []float64{} - p15 := []string{} - - cross_call_master.ParamRefVectorsCallback(&p1, &p2, &p3, &p4, &p5, &p6, &p7, &p8, &p9, &p10, &p11, &p12, &p13, &p14, &p15) - - p1Formatted := formatArray(p1) - p2Formatted := formatArrayFmt(p2, formatChr) - p3Formatted := formatArray(p3) - p4Formatted := formatArray(p4) - p5Formatted := formatArray(p5) - p6Formatted := formatArray(p6) - p7Formatted := formatArray(p7) - p8Formatted := formatArray(p8) - p9Formatted := formatArray(p9) - p10Formatted := formatArray(p10) - p11Formatted := formatArray(p11) - p12Formatted := formatArrayFmt(p12, formatPtr) - p13Formatted := formatArray(p13) - p14Formatted := formatArray(p14) - p15Formatted := formatArrayFmt(p15, formatStr) - - return fmt.Sprintf("%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s", - p1Formatted, p2Formatted, p3Formatted, p4Formatted, p5Formatted, p6Formatted, p7Formatted, - p8Formatted, p9Formatted, p10Formatted, p11Formatted, p12Formatted, p13Formatted, p14Formatted, - p15Formatted) -} - -func ReverseParamAllPrimitives() string { - result := cross_call_master.ParamAllPrimitivesCallback( - true, // bool - '%', // char8 - '☢', // char16 - -1, // int8 - -1000, // int16 - -1000000, // int32 - -1000000000000, // int64 - 200, // uint8 - 50000, // uint16 - 3000000000, // uint32 - 9999999999, // uint64 - 0xfedcbaabcdef, // uintptr (used for pointer simulation) - 0.001, // float32 - 987654.456789, // float64 - ) - return fmt.Sprintf("%d", result) -} - -func ReverseParamEnum() string { - p1 := cross_call_master.Forth - p2 := []cross_call_master.Example{cross_call_master.First, cross_call_master.Second, cross_call_master.Third} - result := cross_call_master.ParamEnumCallback(p1, p2) - return fmt.Sprintf("%d", result) -} - -func ReverseParamEnumRef() string { - p1 := cross_call_master.First - p2 := []cross_call_master.Example{cross_call_master.First, cross_call_master.First, cross_call_master.Second} - result := cross_call_master.ParamEnumRefCallback(&p1, &p2) - return fmt.Sprintf("%d|%d|%s", result, p1, formatArray(p2)) -} - -func ReverseParamVariant() string { - p1 := "my custom string with enough chars" - p2 := []any{'X', '☢', -1, -1000, -1000000, -1000000000000, 200, 50000, 3000000000, 9999999999, 0xfedcbaabcdef, 0.001, 987654.456789} - cross_call_master.ParamVariantCallback(p1, p2) - return fmt.Sprintf("%s|%v", p1, p2) -} - -func ReverseParamVariantRef() string { - var p1 any = "my custom string with enough chars" - p2 := []any{int8('X'), uint16('☢'), int32(-1), int32(-1000), int32(-1000000), int64(-1000000000000), int32(200), int32(50000), int64(3000000000), int64(9999999999), uintptr(0xfedcbaabcdef), float32(0.001), float32(987654.456789)} - cross_call_master.ParamVariantRefCallback(&p1, &p2) - return fmt.Sprintf("%s|{%v, %v, %s}", formatArray(p1.([]int32)), p2[0].(bool), formatFlt32(p2[1].(float32)), p2[2].(string)) -} - -func ReverseCallFuncVoid() string { - cross_call_master.CallFuncVoidCallback(MockVoid) - return "" -} - -func ReverseCallFuncBool() string { - result := cross_call_master.CallFuncBoolCallback(MockBool) - return formatBool(result) -} - -func ReverseCallFuncChar8() string { - result := cross_call_master.CallFuncChar8Callback(MockChar8) - return fmt.Sprintf("%d", result) -} - -func ReverseCallFuncChar16() string { - result := cross_call_master.CallFuncChar16Callback(MockChar16) - return fmt.Sprintf("%d", result) -} - -func ReverseCallFuncInt8() string { - result := cross_call_master.CallFuncInt8Callback(MockInt8) - return fmt.Sprintf("%d", result) -} - -func ReverseCallFuncInt16() string { - result := cross_call_master.CallFuncInt16Callback(MockInt16) - return fmt.Sprintf("%d", result) -} - -func ReverseCallFuncInt32() string { - result := cross_call_master.CallFuncInt32Callback(MockInt32) - return fmt.Sprintf("%d", result) -} - -func ReverseCallFuncInt64() string { - result := cross_call_master.CallFuncInt64Callback(MockInt64) - return fmt.Sprintf("%d", result) -} - -func ReverseCallFuncUInt8() string { - result := cross_call_master.CallFuncUInt8Callback(MockUInt8) - return fmt.Sprintf("%d", result) -} - -func ReverseCallFuncUInt16() string { - result := cross_call_master.CallFuncUInt16Callback(MockUInt16) - return fmt.Sprintf("%d", result) -} - -func ReverseCallFuncUInt32() string { - result := cross_call_master.CallFuncUInt32Callback(MockUInt32) - return fmt.Sprintf("%d", result) -} - -func ReverseCallFuncUInt64() string { - result := cross_call_master.CallFuncUInt64Callback(MockUInt64) - return fmt.Sprintf("%d", result) -} - -func ReverseCallFuncPtr() string { - result := cross_call_master.CallFuncPtrCallback(MockPtr) - return fmt.Sprintf("0x%x", result) -} - -func ReverseCallFuncFloat() string { - result := cross_call_master.CallFuncFloatCallback(MockFloat) - return fmt.Sprintf("%v", formatFlt32(result)) -} - -func ReverseCallFuncDouble() string { - result := cross_call_master.CallFuncDoubleCallback(MockDouble) - return fmt.Sprintf("%v", formatFlt64(result)) -} - -func ReverseCallFuncString() string { - result := cross_call_master.CallFuncStringCallback(MockString) - return result -} - -func ReverseCallFuncAny() string { - result := cross_call_master.CallFuncAnyCallback(MockAny) - return fmt.Sprintf("%c", result.(uint16)) -} - -func ReverseCallFuncBoolVector() string { - result := cross_call_master.CallFuncBoolVectorCallback(MockBoolArray) - return formatArrayFmt(result, formatBool) -} - -func ReverseCallFuncChar8Vector() string { - result := cross_call_master.CallFuncChar8VectorCallback(MockChar8Array) - return formatArrayFmt(result, formatChr) -} - -func ReverseCallFuncChar16Vector() string { - result := cross_call_master.CallFuncChar16VectorCallback(MockChar16Array) - return formatArray(result) -} - -func ReverseCallFuncInt8Vector() string { - result := cross_call_master.CallFuncInt8VectorCallback(MockInt8Array) - return formatArray(result) -} - -func ReverseCallFuncInt16Vector() string { - result := cross_call_master.CallFuncInt16VectorCallback(MockInt16Array) - return formatArray(result) -} - -func ReverseCallFuncInt32Vector() string { - result := cross_call_master.CallFuncInt32VectorCallback(MockInt32Array) - return formatArray(result) -} - -func ReverseCallFuncInt64Vector() string { - result := cross_call_master.CallFuncInt64VectorCallback(MockInt64Array) - return formatArray(result) -} - -func ReverseCallFuncUInt8Vector() string { - result := cross_call_master.CallFuncUInt8VectorCallback(MockUInt8Array) - return formatArray(result) -} - -func ReverseCallFuncUInt16Vector() string { - result := cross_call_master.CallFuncUInt16VectorCallback(MockUInt16Array) - return formatArray(result) -} - -func ReverseCallFuncUInt32Vector() string { - result := cross_call_master.CallFuncUInt32VectorCallback(MockUInt32Array) - return formatArray(result) -} - -func ReverseCallFuncUInt64Vector() string { - result := cross_call_master.CallFuncUInt64VectorCallback(MockUInt64Array) - return formatArray(result) -} - -func ReverseCallFuncPtrVector() string { - result := cross_call_master.CallFuncPtrVectorCallback(MockPtrArray) - return formatArrayFmt(result, formatPtr) -} - -func ReverseCallFuncFloatVector() string { - result := cross_call_master.CallFuncFloatVectorCallback(MockFloatArray) - return formatArrayFmt(result, formatFlt32) -} - -func ReverseCallFuncDoubleVector() string { - result := cross_call_master.CallFuncDoubleVectorCallback(MockDoubleArray) - return formatArrayFmt(result, formatFlt64) -} - -func ReverseCallFuncStringVector() string { - result := cross_call_master.CallFuncStringVectorCallback(MockStringArray) - return formatArrayFmt(result, formatStr) -} - -func ReverseCallFuncAnyVector() string { - result := cross_call_master.CallFuncAnyVectorCallback(MockAnyArray) - return formatArrayFmt(result, formatAny) -} - -func ReverseCallFuncVec2Vector() string { - result := cross_call_master.CallFuncVec2VectorCallback(MockVec2Array) - return formatArrayFmt(result, formatVector2) -} - -func ReverseCallFuncVec3Vector() string { - result := cross_call_master.CallFuncVec3VectorCallback(MockVec3Array) - return formatArrayFmt(result, formatVector3) -} - -func ReverseCallFuncVec4Vector() string { - result := cross_call_master.CallFuncVec4VectorCallback(MockVec4Array) - return formatArrayFmt(result, formatVector4) -} - -func ReverseCallFuncMat4x4Vector() string { - result := cross_call_master.CallFuncMat4x4VectorCallback(MockMat4x4Array) - return formatArrayFmt(result, formatMatrix4x4) -} - -func ReverseCallFuncVec2() string { - result := cross_call_master.CallFuncVec2Callback(MockVec2) - return formatVector2(result) -} - -func ReverseCallFuncVec3() string { - result := cross_call_master.CallFuncVec3Callback(MockVec3) - return formatVector3(result) -} - -func ReverseCallFuncVec4() string { - result := cross_call_master.CallFuncVec4Callback(MockVec4) - return formatVector4(result) -} - -func ReverseCallFuncMat4x4() string { - result := cross_call_master.CallFuncMat4x4Callback(MockMat4x4) - return formatMatrix4x4(result) -} - -func ReverseCallFunc1() string { - result := cross_call_master.CallFunc1Callback(MockFunc1) - return fmt.Sprintf("%d", result) -} - -func ReverseCallFunc2() string { - result := cross_call_master.CallFunc2Callback(MockFunc2) - return fmt.Sprintf("%c", result) -} - -func ReverseCallFunc3() string { - cross_call_master.CallFunc3Callback(MockFunc3) - return "" -} - -func ReverseCallFunc4() string { - result := cross_call_master.CallFunc4Callback(MockFunc4) - return formatVector4(result) -} - -func ReverseCallFunc5() string { - result := cross_call_master.CallFunc5Callback(MockFunc5) - return fmt.Sprintf("%t", result) -} - -func ReverseCallFunc6() string { - result := cross_call_master.CallFunc6Callback(MockFunc6) - return fmt.Sprintf("%d", result) -} - -func ReverseCallFunc7() string { - result := cross_call_master.CallFunc7Callback(MockFunc7) - return fmt.Sprintf("%v", formatFlt64(result)) -} - -func ReverseCallFunc8() string { - result := cross_call_master.CallFunc8Callback(MockFunc8) - return formatMatrix4x4(result) -} - -func ReverseCallFunc9() string { - cross_call_master.CallFunc9Callback(MockFunc9) - return "" -} - -func ReverseCallFunc10() string { - result := cross_call_master.CallFunc10Callback(MockFunc10) - return fmt.Sprintf("%d", result) -} - -func ReverseCallFunc11() string { - result := cross_call_master.CallFunc11Callback(MockFunc11) - return fmt.Sprintf("0x%x", result) -} - -func ReverseCallFunc12() string { - result := cross_call_master.CallFunc12Callback(MockFunc12) - return fmt.Sprintf("%t", result) -} - -func ReverseCallFunc13() string { - result := cross_call_master.CallFunc13Callback(MockFunc13) - return result -} - -func ReverseCallFunc14() string { - result := cross_call_master.CallFunc14Callback(MockFunc14) - return formatArrayFmt(result, formatStr) -} - -func ReverseCallFunc15() string { - result := cross_call_master.CallFunc15Callback(MockFunc15) - return fmt.Sprintf("%d", result) -} - -func ReverseCallFunc16() string { - result := cross_call_master.CallFunc16Callback(MockFunc16) - return fmt.Sprintf("0x%x", result) -} - -func ReverseCallFunc17() string { - result := cross_call_master.CallFunc17Callback(MockFunc17) - return result -} - -func ReverseCallFunc18() string { - result := cross_call_master.CallFunc18Callback(MockFunc18) - return result -} - -func ReverseCallFunc19() string { - result := cross_call_master.CallFunc19Callback(MockFunc19) - return result -} - -func ReverseCallFunc20() string { - result := cross_call_master.CallFunc20Callback(MockFunc20) - return result -} - -func ReverseCallFunc21() string { - result := cross_call_master.CallFunc21Callback(MockFunc21) - return result -} - -func ReverseCallFunc22() string { - result := cross_call_master.CallFunc22Callback(MockFunc22) - return result -} - -func ReverseCallFunc23() string { - result := cross_call_master.CallFunc23Callback(MockFunc23) - return result -} - -func ReverseCallFunc24() string { - result := cross_call_master.CallFunc24Callback(MockFunc24) - return result -} - -func ReverseCallFunc25() string { - result := cross_call_master.CallFunc25Callback(MockFunc25) - return result -} - -func ReverseCallFunc26() string { - result := cross_call_master.CallFunc26Callback(MockFunc26) - return result -} - -func ReverseCallFunc27() string { - result := cross_call_master.CallFunc27Callback(MockFunc27) - return result -} - -func ReverseCallFunc28() string { - result := cross_call_master.CallFunc28Callback(MockFunc28) - return result -} - -func ReverseCallFunc29() string { - result := cross_call_master.CallFunc29Callback(MockFunc29) - return result -} - -func ReverseCallFunc30() string { - result := cross_call_master.CallFunc30Callback(MockFunc30) - return result -} - -func ReverseCallFunc31() string { - result := cross_call_master.CallFunc31Callback(MockFunc31) - return result -} - -func ReverseCallFunc32() string { - result := cross_call_master.CallFunc32Callback(MockFunc32) - return result -} - -func ReverseCallFunc33() string { - result := cross_call_master.CallFunc33Callback(MockFunc33) - return result -} - -func ReverseCallFuncEnum() string { - result := cross_call_master.CallFuncEnumCallback(MockFuncEnum) - return result -} - -var ReverseTest = map[string]func() string{ - "NoParamReturnVoid": ReverseNoParamReturnVoid, - "NoParamReturnBool": ReverseNoParamReturnBool, - "NoParamReturnChar8": ReverseNoParamReturnChar8, - "NoParamReturnChar16": ReverseNoParamReturnChar16, - "NoParamReturnInt8": ReverseNoParamReturnInt8, - "NoParamReturnInt16": ReverseNoParamReturnInt16, - "NoParamReturnInt32": ReverseNoParamReturnInt32, - "NoParamReturnInt64": ReverseNoParamReturnInt64, - "NoParamReturnUInt8": ReverseNoParamReturnUInt8, - "NoParamReturnUInt16": ReverseNoParamReturnUInt16, - "NoParamReturnUInt32": ReverseNoParamReturnUInt32, - "NoParamReturnUInt64": ReverseNoParamReturnUInt64, - "NoParamReturnPointer": ReverseNoParamReturnPointer, - "NoParamReturnFloat": ReverseNoParamReturnFloat, - "NoParamReturnDouble": ReverseNoParamReturnDouble, - "NoParamReturnFunction": ReverseNoParamReturnFunction, - "NoParamReturnString": ReverseNoParamReturnString, - "NoParamReturnAny": ReverseNoParamReturnAny, - "NoParamReturnArrayBool": ReverseNoParamReturnArrayBool, - "NoParamReturnArrayChar8": ReverseNoParamReturnArrayChar8, - "NoParamReturnArrayChar16": ReverseNoParamReturnArrayChar16, - "NoParamReturnArrayInt8": ReverseNoParamReturnArrayInt8, - "NoParamReturnArrayInt16": ReverseNoParamReturnArrayInt16, - "NoParamReturnArrayInt32": ReverseNoParamReturnArrayInt32, - "NoParamReturnArrayInt64": ReverseNoParamReturnArrayInt64, - "NoParamReturnArrayUInt8": ReverseNoParamReturnArrayUInt8, - "NoParamReturnArrayUInt16": ReverseNoParamReturnArrayUInt16, - "NoParamReturnArrayUInt32": ReverseNoParamReturnArrayUInt32, - "NoParamReturnArrayUInt64": ReverseNoParamReturnArrayUInt64, - "NoParamReturnArrayPointer": ReverseNoParamReturnArrayPointer, - "NoParamReturnArrayFloat": ReverseNoParamReturnArrayFloat, - "NoParamReturnArrayDouble": ReverseNoParamReturnArrayDouble, - "NoParamReturnArrayString": ReverseNoParamReturnArrayString, - "NoParamReturnArrayAny": ReverseNoParamReturnArrayAny, - "NoParamReturnVector2": ReverseNoParamReturnVector2, - "NoParamReturnVector3": ReverseNoParamReturnVector3, - "NoParamReturnVector4": ReverseNoParamReturnVector4, - "NoParamReturnMatrix4x4": ReverseNoParamReturnMatrix4x4, - "Param1": ReverseParam1, - "Param2": ReverseParam2, - "Param3": ReverseParam3, - "Param4": ReverseParam4, - "Param5": ReverseParam5, - "Param6": ReverseParam6, - "Param7": ReverseParam7, - "Param8": ReverseParam8, - "Param9": ReverseParam9, - "Param10": ReverseParam10, - "ParamRef1": ReverseParamRef1, - "ParamRef2": ReverseParamRef2, - "ParamRef3": ReverseParamRef3, - "ParamRef4": ReverseParamRef4, - "ParamRef5": ReverseParamRef5, - "ParamRef6": ReverseParamRef6, - "ParamRef7": ReverseParamRef7, - "ParamRef8": ReverseParamRef8, - "ParamRef9": ReverseParamRef9, - "ParamRef10": ReverseParamRef10, - "ParamRefArrays": ReverseParamRefVectors, - "ParamAllPrimitives": ReverseParamAllPrimitives, - "ParamEnum": ReverseParamEnum, - "ParamEnumRef": ReverseParamEnumRef, - "ParamVariant": ReverseParamVariant, - "ParamVariantRef": ReverseParamVariantRef, - "CallFuncVoid": ReverseCallFuncVoid, - "CallFuncBool": ReverseCallFuncBool, - "CallFuncChar8": ReverseCallFuncChar8, - "CallFuncChar16": ReverseCallFuncChar16, - "CallFuncInt8": ReverseCallFuncInt8, - "CallFuncInt16": ReverseCallFuncInt16, - "CallFuncInt32": ReverseCallFuncInt32, - "CallFuncInt64": ReverseCallFuncInt64, - "CallFuncUInt8": ReverseCallFuncUInt8, - "CallFuncUInt16": ReverseCallFuncUInt16, - "CallFuncUInt32": ReverseCallFuncUInt32, - "CallFuncUInt64": ReverseCallFuncUInt64, - "CallFuncPtr": ReverseCallFuncPtr, - "CallFuncFloat": ReverseCallFuncFloat, - "CallFuncDouble": ReverseCallFuncDouble, - "CallFuncString": ReverseCallFuncString, - "CallFuncAny": ReverseCallFuncAny, - "CallFuncBoolVector": ReverseCallFuncBoolVector, - "CallFuncChar8Vector": ReverseCallFuncChar8Vector, - "CallFuncChar16Vector": ReverseCallFuncChar16Vector, - "CallFuncInt8Vector": ReverseCallFuncInt8Vector, - "CallFuncInt16Vector": ReverseCallFuncInt16Vector, - "CallFuncInt32Vector": ReverseCallFuncInt32Vector, - "CallFuncInt64Vector": ReverseCallFuncInt64Vector, - "CallFuncUInt8Vector": ReverseCallFuncUInt8Vector, - "CallFuncUInt16Vector": ReverseCallFuncUInt16Vector, - "CallFuncUInt32Vector": ReverseCallFuncUInt32Vector, - "CallFuncUInt64Vector": ReverseCallFuncUInt64Vector, - "CallFuncPtrVector": ReverseCallFuncPtrVector, - "CallFuncFloatVector": ReverseCallFuncFloatVector, - "CallFuncDoubleVector": ReverseCallFuncDoubleVector, - "CallFuncStringVector": ReverseCallFuncStringVector, - "CallFuncAnyVector": ReverseCallFuncAnyVector, - "CallFuncVec2Vector": ReverseCallFuncVec2Vector, - "CallFuncVec3Vector": ReverseCallFuncVec3Vector, - "CallFuncVec4Vector": ReverseCallFuncVec4Vector, - "CallFuncMat4x4Vector": ReverseCallFuncMat4x4Vector, - "CallFuncVec2": ReverseCallFuncVec2, - "CallFuncVec3": ReverseCallFuncVec3, - "CallFuncVec4": ReverseCallFuncVec4, - "CallFuncMat4x4": ReverseCallFuncMat4x4, - "CallFunc1": ReverseCallFunc1, - "CallFunc2": ReverseCallFunc2, - "CallFunc3": ReverseCallFunc3, - "CallFunc4": ReverseCallFunc4, - "CallFunc5": ReverseCallFunc5, - "CallFunc6": ReverseCallFunc6, - "CallFunc7": ReverseCallFunc7, - "CallFunc8": ReverseCallFunc8, - "CallFunc9": ReverseCallFunc9, - "CallFunc10": ReverseCallFunc10, - "CallFunc11": ReverseCallFunc11, - "CallFunc12": ReverseCallFunc12, - "CallFunc13": ReverseCallFunc13, - "CallFunc14": ReverseCallFunc14, - "CallFunc15": ReverseCallFunc15, - "CallFunc16": ReverseCallFunc16, - "CallFunc17": ReverseCallFunc17, - "CallFunc18": ReverseCallFunc18, - "CallFunc19": ReverseCallFunc19, - "CallFunc20": ReverseCallFunc20, - "CallFunc21": ReverseCallFunc21, - "CallFunc22": ReverseCallFunc22, - "CallFunc23": ReverseCallFunc23, - "CallFunc24": ReverseCallFunc24, - "CallFunc25": ReverseCallFunc25, - "CallFunc26": ReverseCallFunc26, - "CallFunc27": ReverseCallFunc27, - "CallFunc28": ReverseCallFunc28, - "CallFunc29": ReverseCallFunc29, - "CallFunc30": ReverseCallFunc30, - "CallFunc31": ReverseCallFunc31, - "CallFunc32": ReverseCallFunc32, - "CallFunc33": ReverseCallFunc33, - "CallFuncEnum": ReverseCallFuncEnum, -} - -func ReverseCall(test string) { - // Retrieve the function from the map - if method, exists := ReverseTest[test]; exists { - // Call the function and get the result - result := method() - if result != "" { - // Call the ReverseReturn function with the result - cross_call_master.ReverseReturn(result) - } - } else { - // Print an error message if the function is not found - fmt.Printf("Method '%s' not found.\n", test) - } -} diff --git a/version.txt b/version.txt index e010258..157e54f 100644 --- a/version.txt +++ b/version.txt @@ -1 +1 @@ -2.0.5 +2.0.6