invoke cleanup

Content/Scenes/PerfTest.scene

@@ -0,0 +1,32 @@
+{
+	"ID": "2a86c77242441f5ac25b4a8bbf4029a8",
+	"TypeName": "FlaxEngine.SceneAsset",
+	"EngineBuild": 6804,
+	"Data": [
+		{
+			"ID": "2a86c77242441f5ac25b4a8bbf4029a8",
+			"TypeName": "FlaxEngine.Scene",
+			"LightmapSettings": {
+				"IndirectLightingIntensity": 1.0,
+				"GlobalObjectsScale": 1.0,
+				"ChartsPadding": 3,
+				"AtlasSize": 1024,
+				"BounceCount": 1,
+				"CompressLightmaps": true,
+				"UseGeometryWithNoMaterials": true,
+				"Quality": 10
+			}
+		},
+		{
+			"ID": "5b51518c45ce815817a6f1978fec4699",
+			"TypeName": "Game.MyScript",
+			"ParentID": "2a86c77242441f5ac25b4a8bbf4029a8"
+		},
+		{
+			"ID": "efa3263d4596af098d5babb8fd6ea6fb",
+			"TypeName": "Game.MyScriptTwo",
+			"ParentID": "2a86c77242441f5ac25b4a8bbf4029a8",
+			"V": {}
+		}
+	]
+}

Source/Game/Console/ConsolePlugin.cs

@@ -3,6 +3,8 @@ using FlaxEngine;
 using Console = Game.Console;
 using System.Linq;
 using System.Threading;
+using FlaxEngine.Json;
+
 
 #if FLAX_EDITOR
 using FlaxEditor;
@@ -137,6 +139,9 @@ public class ConsoleEditorPlugin : EditorPlugin
 
     private void OnPlayModeBegin()
     {
+        if (!Level.Scenes.Any(x => x.ID == JsonSerializer.ParseID("194e05f445ece24ec5448d886e1334df"))) // MainScene
+            return;
+
         //FlaxEditor.Editor.Instance.PlayModeBegin -= Instance_PlayModeBegin;
         LoadConfig();
         //GameMode.Connect();

Source/Game/MyScript.cpp

@@ -0,0 +1,595 @@
+#include "MyScript.h"
+
+#include "Engine/Content/Content.h"
+#include "Engine/Level/Actor.h"
+#include "Engine/Core/Log.h"
+#include "Engine/Renderer/RenderList.h"
+#include "Engine/Scripting/ManagedCLR/MUtils.h"
+#include "Engine/Scripting/ManagedCLR/MCore.h"
+#include "Engine/Scripting/ManagedCLR/MClass.h"
+#include "Engine/Scripting/ManagedCLR/MEvent.h"
+#include "Engine/Scripting/ManagedCLR/MMethod.h"
+#include "Engine/Level/Scene/Scene.h"
+#include "Engine/Core/Collections/Sorting.h"
+#include "Engine/Render2D/FontAsset.h"
+
+#define NEW_VERSION 1
+
+#if BUILD_DEBUG
+#define LONGER 3
+#define CHUNK_TIMES 100
+#else
+#define LONGER 10//*10
+#define CHUNK_TIMES 1000
+#endif
+#define TIMES (10000*LONGER)
+#define TIMES2 (1000*LONGER)
+#define TIMES3 (100*LONGER)
+#define TIMES4 (10*LONGER)
+#define TIMES5 (1*LONGER)
+#define TIMES_ONCE 1
+
+MyScript2::MyScript2(const SpawnParams& params)
+    : Script(params)
+{
+    //  _tickUpdate = true; 
+
+}
+
+MyScript::MyScript(const SpawnParams& params)
+    : Script(params)
+{
+    //  _tickUpdate = true; 
+    
+}
+
+void MyScript::OnStart()
+{
+    LOG(Info, "C++ OnStart");
+    MyScript2* scriptTwo = (MyScript2*)GetActor()->GetScript(1);
+    if (scriptTwo == nullptr)
+        return;
+
+    bool thunkTests = false;
+    bool invokeTests = true;
+    bool coverageTests = false;
+
+    bool otherTests = true;
+    bool arrayTests = true;
+    bool asRefTests = true;
+
+    Array<uint64> results(TIMES);
+    auto CyclesToSeconds = 1.0 / static_cast<double>(Platform::GetClockFrequency());
+    LOG(Info, "CyclesToSeconds: {}, freq: {}", CyclesToSeconds, Platform::GetClockFrequency());
+    
+    String shortString = TEXT("Testing string parameter marshalling");
+    StringAnsi shortStringAnsi = "Testing string parameter marshalling";
+    Actor* actor = GetActor();
+    SceneReference sceneRef; sceneRef.ID = actor->GetScene()->GetID();
+    BehaviorUpdateContext behaviorUpdateContext = {};
+    RenderContext renderContext = MainRenderTask::Instance;
+    renderContext.List = RenderList::GetFromPool();
+    Array<int> simpleArray; for (int i=0; i<10; i++) simpleArray.Add(i);
+    Array<Actor*> actorArray; for (int i=0; i<10; i++) actorArray.Add(actor);
+    TestStruct testStruct; testStruct.Object = actor; testStruct.SceneRef = sceneRef;
+    Array<TestStruct> complexArray; for (int i=0; i<10; i++) complexArray.Add(testStruct);
+
+
+    // Coverage
+    if (coverageTests)
+    {
+        int32 integer = 1;
+        bool boolean = true;
+        Float3 f3(1.0f, 2.0f, 3.0f);
+        Guid fontAssetGuid; Guid::Parse("ab96b25a49461d9f4f819484cf5c8213", fontAssetGuid);
+        FontAsset* fontAsset = Content::LoadAsync<FontAsset>(fontAssetGuid);
+        NetworkChannelType networkChannelType = NetworkChannelType::Reliable;
+        OnlineLeaderboardSortModes onlineLeaderboardSortModes = OnlineLeaderboardSortModes::Ascending;
+        OnlineLeaderboardValueFormats onlineLeaderboardValueFormats = OnlineLeaderboardValueFormats::Numeric;
+        AssetReference<FontAsset> fontAssetRef(fontAsset);
+        ModelLOD* lod = nullptr;
+
+        Array<int32> ints(&integer, 1);
+        Array<bool> booleans(&boolean, 1);
+        Array<Actor*> actors(&actor, 1);
+        Array<String> strings(&shortString, 1);
+        Array<StringAnsi> ansiStrings(&shortStringAnsi, 1);
+        Array<Float3> float3s(&f3, 1);
+        Array<ModelLOD*> lods(&lod, 1);
+
+        COVERAGE_CALL_ARGS6(CoverageTest1, integer, boolean, actor, shortString, shortStringAnsi, f3);
+        COVERAGE_CALL_ARGS6(CoverageTest1Array, ints, booleans, actors, strings, ansiStrings, float3s);
+
+        COVERAGE_CALL_ARGS5(CoverageTest1ByRef, integer, boolean/*, actor*/, shortString, shortStringAnsi, f3);
+        COVERAGE_CALL_ARGS5(CoverageTest1ArrayByRef, ints, booleans/*, actors*/, strings, ansiStrings, float3s);
+        COVERAGE_CALL_ARGS4(CoverageTest2, fontAssetGuid, fontAssetRef, Array<Guid>(&fontAssetGuid, 1), Array<AssetReference<FontAsset>>(&fontAssetRef, 1));
+        COVERAGE_CALL_ARGS2(CoverageTest3, lod, lods);
+        COVERAGE_CALL_ARGS6(CoverageNamespaces1, networkChannelType, Array<NetworkChannelType>(&networkChannelType, 1), onlineLeaderboardSortModes, Array<OnlineLeaderboardSortModes>(&onlineLeaderboardSortModes, 1), onlineLeaderboardValueFormats, Array<OnlineLeaderboardValueFormats>(&onlineLeaderboardValueFormats, 1));
+
+        scriptTwo->ManagedCoverageTests();
+    }
+
+#if NEW_VERSION
+    int64 allocationsBefore, deallocationsBefore;
+    scriptTwo->GetStats(allocationsBefore, deallocationsBefore);
+#endif
+
+    if (otherTests)
+    {
+        LOG_TEST(SimpleCall);
+        if (thunkTests)
+        {
+            BENCHMARK_CALL_ARGS0(TIMES2, SimpleCall);
+            BENCHMARK_THUNK_BEGIN_ARGS0(TIMES2, SimpleCall);
+            BENCHMARK_THUNK_CALL_ARGS0();
+            BENCHMARK_THUNK_END();
+        }
+        if (invokeTests)
+        {
+            BENCHMARK_INVOKE_ARGS0(TIMES2, SimpleCall);
+        }
+    }
+
+    if (otherTests)
+    {
+        LOG_TEST(SimpleParams);
+        if (thunkTests)
+        {
+            BENCHMARK_CALL_ARGS5(TIMES4, SimpleParams, 1, 2, '3', 4, 5);
+            BENCHMARK_THUNK_BEGIN_ARGS5(TIMES3, SimpleParams);
+            params[0] = MUtils::Box<int>(1, MCore::TypeCache::Int32);
+            params[1] = MUtils::Box<float>(2, MCore::TypeCache::Single);
+            params[2] = MUtils::Box<char>('3', MCore::TypeCache::SByte);
+            params[3] = MUtils::Box<double>(4, MCore::TypeCache::Double);
+            params[4] = MUtils::Box<long>(5, MCore::TypeCache::Int64);
+            BENCHMARK_THUNK_CALL_ARGS5();
+#if NEW_VERSION
+            auto __param0_handle = *(MGCHandle*)&params[0];
+            MCore::GCHandle::Free(__param0_handle);
+            auto __param1_handle = *(MGCHandle*)&params[1];
+            MCore::GCHandle::Free(__param1_handle);
+            auto __param2_handle = *(MGCHandle*)&params[2];
+            MCore::GCHandle::Free(__param2_handle);
+            auto __param3_handle = *(MGCHandle*)&params[3];
+            MCore::GCHandle::Free(__param3_handle);
+            auto __param4_handle = *(MGCHandle*)&params[4];
+            MCore::GCHandle::Free(__param4_handle);
+#endif
+            BENCHMARK_THUNK_END();
+        }
+        if (invokeTests)
+        {
+            BENCHMARK_INVOKE_ARGS5(TIMES3, SimpleParams,
+                MUtils::Box<int>(1, MCore::TypeCache::Int32),
+                MUtils::Box<float>(2, MCore::TypeCache::Single),
+                MUtils::Box<char>('3', MCore::TypeCache::SByte),
+                MUtils::Box<double>(4, MCore::TypeCache::Double),
+                MUtils::Box<long>(5, MCore::TypeCache::Int64));
+#if NEW_VERSION
+            auto __param0_handle = *(MGCHandle*)&params[0];
+            MCore::GCHandle::Free(__param0_handle);
+            auto __param1_handle = *(MGCHandle*)&params[1];
+            MCore::GCHandle::Free(__param1_handle);
+            auto __param2_handle = *(MGCHandle*)&params[2];
+            MCore::GCHandle::Free(__param2_handle);
+            auto __param3_handle = *(MGCHandle*)&params[3];
+            MCore::GCHandle::Free(__param3_handle);
+            auto __param4_handle = *(MGCHandle*)&params[4];
+            MCore::GCHandle::Free(__param4_handle);
+#endif
+        }
+    }
+
+
+    if (otherTests)
+    {
+        LOG_TEST(StringParamAnsi);
+        if (thunkTests)
+        {
+            BENCHMARK_CALL_ARGS1(TIMES3, StringParamAnsi, shortStringAnsi);
+            BENCHMARK_THUNK_BEGIN_ARGS1(TIMES2, StringParamAnsi);
+            params[0] = MUtils::Box<StringAnsi>(shortStringAnsi, MCore::TypeCache::String);
+            BENCHMARK_THUNK_CALL_ARGS1();
+#if NEW_VERSION
+            MUtils::FreeManaged<StringAnsi>((MObject*)params[0]);
+#endif
+            BENCHMARK_THUNK_END();
+        }
+        if (invokeTests)
+        {
+            BENCHMARK_INVOKE_ARGS1(TIMES2, StringParamAnsi,
+                MUtils::Box<StringAnsi>(shortStringAnsi, MCore::TypeCache::String));
+#if NEW_VERSION
+            MUtils::FreeManaged<StringAnsi>((MObject*)params[0]);
+#endif
+        }
+    }
+    if (otherTests)
+    {
+        LOG_TEST(StringParam);
+        if (thunkTests)
+        {
+            BENCHMARK_CALL_ARGS1(TIMES3, StringParam, shortString);
+            BENCHMARK_THUNK_BEGIN_ARGS1(TIMES2, StringParam);
+            params[0] = MUtils::Box<String>(shortString, MCore::TypeCache::String);
+            BENCHMARK_THUNK_CALL_ARGS1();
+#if NEW_VERSION
+            MUtils::FreeManaged<String>((MObject*)params[0]);
+#endif
+            BENCHMARK_THUNK_END();
+        }
+        if (invokeTests)
+        {
+            BENCHMARK_INVOKE_ARGS1(TIMES2, StringParam,
+                MUtils::Box<String>(shortString, MCore::TypeCache::String));
+#if NEW_VERSION
+            MUtils::FreeManaged<String>((MObject*)params[0]);
+#endif
+        }
+    }
+    if (otherTests)
+    {
+        LOG_TEST(StringParamRef);
+        if (thunkTests)
+        {
+            BENCHMARK_CALL_ARGS1(TIMES3, StringParamRef, shortString);
+            BENCHMARK_THUNK_BEGIN_ARGS1(TIMES2, StringParamRef);
+            params[0] = MUtils::Box<String>(shortString, MCore::TypeCache::String);
+            BENCHMARK_THUNK_CALL_ARGS1();
+#if NEW_VERSION
+            MUtils::FreeManaged<String>((MObject*)params[0]);
+#endif
+            BENCHMARK_THUNK_END();
+        }
+        if (invokeTests)
+        {
+            BENCHMARK_INVOKE_ARGS1(TIMES2, StringParamRef,
+                MUtils::Box<String>(shortString, MCore::TypeCache::String));
+#if NEW_VERSION
+            MUtils::FreeManaged<String>((MObject*)params[0]);
+#endif
+        }
+    }
+    if (otherTests)
+    {
+        LOG_TEST(StringParamRefConst);
+        if (thunkTests)
+        {
+            BENCHMARK_CALL_ARGS1(TIMES3, StringParamRefConst, shortString);
+            BENCHMARK_THUNK_BEGIN_ARGS1(TIMES2, StringParamRefConst);
+            params[0] = MUtils::Box<String>(shortString, MCore::TypeCache::String);
+            BENCHMARK_THUNK_CALL_ARGS1();
+#if NEW_VERSION
+            MUtils::FreeManaged<String>((MObject*)params[0]);
+#endif
+            BENCHMARK_THUNK_END();
+        }
+        if (invokeTests)
+        {
+            BENCHMARK_INVOKE_ARGS1(TIMES2, StringParamRefConst,
+                MUtils::Box<String>(shortString, MCore::TypeCache::String));
+#if NEW_VERSION
+            MUtils::FreeManaged<String>((MObject*)params[0]);
+#endif
+        }
+    }
+    if (asRefTests)
+    {
+        LOG_TEST(StringParamAsRef);
+        if (thunkTests)
+        {
+            String str = shortString;
+            BENCHMARK_CALL_ARGS1_REF(TIMES3, StringParamAsRef, str);
+            LOG(Info, "  - InvokeThunkOnly: not valid");
+            /*        str = shortString;
+                    BENCHMARK_THUNK_BEGIN_ARGS1(TIMES3, StringParamAsRef);
+            #if NEW_VERSION
+                    auto __param_orig_str = MUtils::Box<String>(str, MCore::TypeCache::String);
+                    auto __param_str = __param_orig_str;
+                    params[0] = &__param_str;
+            #else
+                    auto __param_str = MUtils::Box<String>(str, MCore::TypeCache::String);
+                    params[0] = &__param_str;
+            #endif
+                    BENCHMARK_THUNK_CALL_ARGS1_REF({ params[0] = &__param_str; });
+                    str = MUtils::Unbox<String>(*(MObject**)params[0]);
+                    ASSERT(str == shortString);
+            #if NEW_VERSION
+                    MUtils::FreeManaged<String>((MObject*)__param_str);
+                    if (__param_orig_str != __param_str)
+                        MUtils::FreeManaged<String>((MObject*)__param_orig_str);
+            #endif
+                    BENCHMARK_THUNK_END();*/
+        }
+        if (invokeTests)
+        {
+            String str = shortString;
+            BENCHMARK_INVOKE_ARGS1_REF(TIMES3, StringParamAsRef,
+                MUtils::Box<String>(str, MCore::TypeCache::String),
+                MUtils::FreeManaged<String>);
+        }
+    }
+
+
+    if (otherTests)
+    {
+        LOG_TEST(ActorParam);
+        if (thunkTests)
+        {
+            BENCHMARK_CALL_ARGS1(TIMES2, ActorParam, actor);
+            BENCHMARK_THUNK_BEGIN_ARGS1(TIMES2, ActorParam);
+            params[0] = ScriptingObject::ToManaged((ScriptingObject*)actor);
+            BENCHMARK_THUNK_CALL_ARGS1();
+            BENCHMARK_THUNK_END();
+        }
+        if (invokeTests)
+        {
+            BENCHMARK_INVOKE_ARGS1(TIMES2, ActorParam,
+                ScriptingObject::ToManaged((ScriptingObject*)actor));
+        }
+    }
+
+
+    if (otherTests)
+    {
+        LOG_TEST(ComplexParam);
+        if (thunkTests)
+        {
+            BENCHMARK_CALL_ARGS1(TIMES3, ComplexParam, behaviorUpdateContext);
+            BENCHMARK_THUNK_BEGIN_ARGS1(TIMES2, ComplexParam);
+            params[0] = MUtils::Box<BehaviorUpdateContext>(behaviorUpdateContext, BehaviorUpdateContext::TypeInitializer.GetClass());
+            BENCHMARK_THUNK_CALL_ARGS1();
+#if NEW_VERSION
+            MUtils::FreeManaged<BehaviorUpdateContext>((MObject*)params[0]);
+#endif
+            BENCHMARK_THUNK_END();
+        }
+        if (invokeTests)
+        {
+            BENCHMARK_INVOKE_ARGS1(TIMES2, ComplexParam,
+                MUtils::Box<BehaviorUpdateContext>(behaviorUpdateContext, BehaviorUpdateContext::TypeInitializer.GetClass()));
+#if NEW_VERSION
+            MUtils::FreeManaged<BehaviorUpdateContext>((MObject*)params[0]);
+#endif
+        }
+    }
+
+
+    if (otherTests)
+    {
+        LOG_TEST(Complex2Param);
+        if (thunkTests)
+        {
+            BENCHMARK_CALL_ARGS1(TIMES4, Complex2Param, renderContext);
+            BENCHMARK_THUNK_BEGIN_ARGS1(TIMES3, Complex2Param);
+            params[0] = MUtils::Box<RenderContext>(renderContext, RenderContext::TypeInitializer.GetClass());
+            BENCHMARK_THUNK_CALL_ARGS1();
+#if NEW_VERSION
+            MUtils::FreeManaged<RenderContext>((MObject*)params[0]);
+#endif
+            BENCHMARK_THUNK_END();
+        }
+        if (invokeTests)
+        {
+            BENCHMARK_INVOKE_ARGS1(TIMES3, Complex2Param,
+                MUtils::Box<RenderContext>(renderContext, RenderContext::TypeInitializer.GetClass()));
+#if NEW_VERSION
+            MUtils::FreeManaged<RenderContext>((MObject*)params[0]);
+#endif
+        }
+    }
+    if (otherTests)
+    {
+        LOG_TEST(Complex2ParamConst);
+        if (thunkTests)
+        {
+            BENCHMARK_CALL_ARGS1(TIMES4, Complex2ParamConst, renderContext);
+            BENCHMARK_THUNK_BEGIN_ARGS1(TIMES3, Complex2ParamConst);
+            params[0] = MUtils::Box<RenderContext>(renderContext, RenderContext::TypeInitializer.GetClass());
+            BENCHMARK_THUNK_CALL_ARGS1();
+#if NEW_VERSION
+            MUtils::FreeManaged<RenderContext>((MObject*)params[0]);
+#endif
+            BENCHMARK_THUNK_END();
+        }
+        if (invokeTests)
+        {
+            BENCHMARK_INVOKE_ARGS1(TIMES3, Complex2ParamConst,
+                MUtils::Box<RenderContext>(renderContext, RenderContext::TypeInitializer.GetClass()));
+#if NEW_VERSION
+            MUtils::FreeManaged<RenderContext>((MObject*)params[0]);
+#endif
+        }
+    }
+    if (asRefTests)
+    {
+        LOG_TEST(Complex2ParamAsRef);
+        if (thunkTests)
+        {
+            RenderContext context = renderContext;
+            BENCHMARK_CALL_ARGS1_REF(TIMES4, Complex2ParamAsRef, context);
+            LOG(Info, "  - InvokeThunkOnly: not valid");
+            /*        context = renderContext;
+                    BENCHMARK_THUNK_BEGIN_ARGS1(TIMES3, Complex2ParamAsRef);
+            #if NEW_VERSION
+                    auto __param_orig_context = MUtils::Box<RenderContext>(context, RenderContext::TypeInitializer.GetClass());
+                    auto __param_context = __param_orig_context;
+                    params[0] = &__param_context;
+            #else
+                    auto __param_context = MUtils::Box<RenderContext>(context, RenderContext::TypeInitializer.GetClass());
+                    params[0] = &__param_context;
+            #endif
+                    BENCHMARK_THUNK_CALL_ARGS1_REF({ if (__param_orig_context != __param_context) MUtils::FreeManaged<RenderContext>((MObject*)__param_orig_context); params[0] = &__param_context; });
+                    context = MUtils::Unbox<RenderContext>(*(MObject**)params[0]);
+                    ASSERT(context.Buffers == renderContext.Buffers);
+                    ASSERT(context.Task == renderContext.Task);
+            #if NEW_VERSION
+                    context = MUtils::Unbox<RenderContext>(*(MObject**)params[0]);
+                    MUtils::FreeManaged<RenderContext>((MObject*)__param_context);
+                    if (__param_orig_context != __param_context)
+                        MUtils::FreeManaged<RenderContext>((MObject*)__param_orig_context);
+            #endif
+                    BENCHMARK_THUNK_END();*/
+        }
+    }
+
+
+    if (arrayTests)
+    {
+        LOG_TEST(SimpleArrayParam);
+        if (thunkTests)
+        {
+            BENCHMARK_CALL_ARGS1(TIMES4, SimpleArrayParam, simpleArray);
+            BENCHMARK_THUNK_BEGIN_ARGS1(TIMES3, SimpleArrayParam);
+            params[0] = MUtils::ToArray(simpleArray, MCore::TypeCache::Int32);
+            BENCHMARK_THUNK_CALL_ARGS1();
+#if NEW_VERSION
+            MUtils::FreeManagedArray<int>((MArray*)params[0]);
+#endif
+            BENCHMARK_THUNK_END();
+        }
+        if (invokeTests)
+        {
+            BENCHMARK_INVOKE_ARGS1(TIMES3, SimpleArrayParam,
+                MUtils::ToArray(simpleArray, MCore::TypeCache::Int32));
+#if NEW_VERSION
+            MUtils::FreeManagedArray<int>((MArray*)params[0]);
+#endif
+        }
+    }
+    if (arrayTests && asRefTests)
+    {
+        LOG_TEST(SimpleArrayParamAsRef);
+        if (thunkTests)
+        {
+            Array<int> arr = simpleArray;
+            BENCHMARK_CALL_ARGS1_REF(TIMES4, SimpleArrayParamAsRef, simpleArray);
+            LOG(Info, "  - InvokeThunkOnly: not valid");
+            /*        arr = simpleArray;
+                    BENCHMARK_THUNK_BEGIN_ARGS1(TIMES3, SimpleArrayParamAsRef);
+            #if NEW_VERSION
+                    auto __param_orig_arr = MUtils::ToArray(arr, MCore::TypeCache::Int32);
+                    auto __param_arr = __param_orig_arr;
+                    params[0] = &__param_arr;
+            #else
+                    auto __param_arr = MUtils::ToArray(arr, MCore::TypeCache::Int32);
+                    params[0] = &__param_arr;
+            #endif
+                    BENCHMARK_THUNK_CALL_ARGS1();
+                    arr = MUtils::Unbox<Array<int>>(*(MObject**)params[0]);
+                    ASSERT(arr.Count() == simpleArray.Count());
+                    for (int i=0; i<arr.Count(); i++) ASSERT(arr[i] == simpleArray[i]);
+            #if NEW_VERSION
+                    MUtils::FreeManagedArray<int>(__param_arr);  //fgfgh3
+                    if (__param_orig_arr != __param_arr)
+                        MUtils::FreeManagedArray<int>(__param_orig_arr);  //fgfgh4
+            #endif
+                    BENCHMARK_THUNK_END();*/
+        }
+    }
+
+
+    if (arrayTests)
+    {
+        LOG_TEST(ActorArrayParam);
+        if (thunkTests)
+        {
+            BENCHMARK_CALL_ARGS1(TIMES4, ActorArrayParam, actorArray);
+            BENCHMARK_THUNK_BEGIN_ARGS1(TIMES3, ActorArrayParam);
+            params[0] = MUtils::ToArray(actorArray, Actor::TypeInitializer.GetClass());
+            BENCHMARK_THUNK_CALL_ARGS1();
+#if NEW_VERSION
+            MUtils::FreeManagedArray<Actor*>((MArray*)params[0]);
+#endif
+            BENCHMARK_THUNK_END();
+        }
+        if (invokeTests)
+        {
+            BENCHMARK_INVOKE_ARGS1(TIMES3, ActorArrayParam,
+                MUtils::ToArray(actorArray, Actor::TypeInitializer.GetClass()));
+#if NEW_VERSION
+            MUtils::FreeManagedArray<Actor*>((MArray*)params[0]);
+#endif
+        }
+    }
+
+    if (arrayTests)
+    {
+        LOG_TEST(ComplexArrayParam);
+        if (thunkTests)
+        {
+            BENCHMARK_CALL_ARGS1(TIMES4, ComplexArrayParam, complexArray);
+            BENCHMARK_THUNK_BEGIN_ARGS1(TIMES3, ComplexArrayParam);
+            params[0] = MUtils::ToArray(complexArray, TestStruct::TypeInitializer.GetClass());
+            BENCHMARK_THUNK_CALL_ARGS1();
+#if NEW_VERSION
+            MUtils::FreeManagedArray<TestStruct>((MArray*)params[0]);
+#endif
+            BENCHMARK_THUNK_END();
+        }
+        if (invokeTests)
+        {
+            BENCHMARK_INVOKE_ARGS1(TIMES3, ComplexArrayParam,
+                MUtils::ToArray(complexArray, TestStruct::TypeInitializer.GetClass()));
+#if NEW_VERSION
+            MUtils::FreeManagedArray<TestStruct>((MArray*)params[0]);
+#endif
+        }
+    }
+    if (arrayTests && asRefTests)
+    {
+        LOG_TEST(ComplexArrayParamAsRef);
+        if (thunkTests)
+        {
+            Array<TestStruct> arr = complexArray;
+            BENCHMARK_CALL_ARGS1_REF(TIMES4, ComplexArrayParamAsRef, arr);
+            LOG(Info, "  - InvokeThunkOnly: not valid");
+            /*        arr = complexArray;
+                    BENCHMARK_THUNK_BEGIN_ARGS1(TIMES4, ComplexArrayParamAsRef);
+
+            #if NEW_VERSION
+                    auto __param_orig_arr = MUtils::ToArray(arr, TestStruct::TypeInitializer.GetClass());
+                    auto __param_arr = __param_orig_arr;
+                    params[0] = &__param_arr;
+            #else
+                    auto __param_arr = MUtils::ToArray(arr, TestStruct::TypeInitializer.GetClass());
+                    params[0] = &__param_arr;
+            #endif
+                    BENCHMARK_THUNK_CALL_ARGS1();
+                    arr = MUtils::Unbox<Array<TestStruct>>(*(MObject**)params[0]);
+                    ASSERT(arr.Count() == complexArray.Count());
+                    for (int i = 0; i < arr.Count(); i++) ASSERT(arr[i] == complexArray[i]);
+            #if NEW_VERSION
+                    MUtils::FreeManagedArray<TestStruct>(__param_arr);
+                    if (__param_orig_arr != __param_arr)
+                        MUtils::FreeManagedArray<TestStruct>(__param_orig_arr);
+            #endif
+                    BENCHMARK_THUNK_END();*/
+        }
+    }
+
+#if NEW_VERSION
+    int64 allocationsAfter, deallocationsAfter;
+    scriptTwo->GetStats(allocationsAfter, deallocationsAfter);
+    int64 allocationsDiff = allocationsAfter-allocationsBefore;
+    int64 deallocationsDiff = deallocationsAfter-deallocationsBefore;
+    int64 leftover = allocationsDiff - deallocationsDiff;
+    LOG(Info, "Total ManagedHandle allocations: {}, deallocations: {}, leftover: {}", allocationsDiff, deallocationsDiff, leftover);
+#endif
+}
+
+void MyScript::OnEnable()
+{
+    //LOG(Info, "C++ OnEnable");
+}
+
+void MyScript::OnDisable()
+{
+    LOG(Info, "running garbage collector");
+    MCore::GC::Collect(MCore::GC::MaxGeneration(), MGCCollectionMode::Aggressive, true, true);
+    MCore::GC::WaitForPendingFinalizers();
+}
+
+void MyScript::OnUpdate()
+{
+}

Source/Game/MyScript.h

@@ -0,0 +1,569 @@
+#pragma once
+
+#include "Engine/Scripting/Script.h"
+#include <Engine/Animations/Curve.h>
+#include <Engine/AI/Behavior.h>
+
+#include "Engine/Graphics/PostProcessEffect.h"
+#include "Engine/Graphics/RenderTask.h"
+#include "Engine/Graphics/Graphics.h"
+#include "Engine/Scripting/SoftTypeReference.h"
+#include "Engine/Content/SceneReference.h"
+#include "Engine/Content/Assets/Model.h"
+#include "Engine/Networking/NetworkChannelType.h"
+#include "Engine/Online/IOnlinePlatform.h"
+#include "Engine/Render2D/FontAsset.h"
+
+API_STRUCT(NoDefault) struct TestStruct : public ISerializable
+{
+    API_AUTO_SERIALIZATION();
+    DECLARE_SCRIPTING_TYPE_MINIMAL(TestStruct);
+
+    // Var
+    API_FIELD() Float3 Vector = Float3::One;
+    // Ref
+    API_FIELD() ScriptingObject* Object = nullptr;
+    // Soft Type Ref
+    API_FIELD() SoftTypeReference<ScriptingObject> SoftTypeRef;
+    // Scene Ref
+    API_FIELD() SceneReference SceneRef;
+
+    friend bool operator==(const TestStruct& lhs, const TestStruct& rhs)
+    {
+        return lhs.Vector == rhs.Vector &&
+            lhs.Object == rhs.Object &&
+            lhs.SoftTypeRef == rhs.SoftTypeRef &&
+            lhs.SceneRef == rhs.SceneRef;
+    }
+};
+
+API_CLASS() class GAME_API MyScript2 : public Script
+{
+    API_AUTO_SERIALIZATION();
+    DECLARE_SCRIPTING_TYPE(MyScript2);
+
+    API_FUNCTION() virtual void GetStats(API_PARAM(Ref) int64& allocations, API_PARAM(Ref) int64& deallocations) {};
+
+    API_FUNCTION() virtual void ManagedCoverageTests() {};
+    API_FUNCTION() virtual void CoverageTest1(int32 a, bool b, Actor* c, String& d, StringAnsi& e, Float3 f) {};
+    API_FUNCTION() virtual void CoverageTest1Array(Array<int32> a, Array<bool> b, Array<Actor*> c, Array<String> d, Array<StringAnsi> e, Array<Float3> f) {};
+    API_FUNCTION() virtual void CoverageTest1ByRef(API_PARAM(Ref) int32& a, API_PARAM(Ref) bool& b, API_PARAM(Ref) String& d, API_PARAM(Ref) StringAnsi& e, API_PARAM(Ref) Float3& f) {};
+    API_FUNCTION() virtual void CoverageTest1ArrayByRef(API_PARAM(Ref) Array<int32>& a, API_PARAM(Ref) Array<bool>& b, API_PARAM(Ref) Array<String>& d, API_PARAM(Ref) Array<StringAnsi>& e, API_PARAM(Ref) Array<Float3>& f) {};
+    API_FUNCTION() virtual void CoverageTest2(Guid a, AssetReference<FontAsset> b, Array<Guid> c, Array<AssetReference<FontAsset>> d) {};
+    API_FUNCTION() virtual void CoverageTest3(ModelLOD* a, API_PARAM(Out) Array<ModelLOD*>& b) {};
+
+    API_FUNCTION() virtual void CoverageNamespaces1(NetworkChannelType a, Array<NetworkChannelType> b, OnlineLeaderboardSortModes c, Array<OnlineLeaderboardSortModes> d, OnlineLeaderboardValueFormats e, Array<OnlineLeaderboardValueFormats> f) {};
+
+    API_FUNCTION() virtual void SimpleCall() {};
+    API_FUNCTION() virtual void SimpleParams(int32 a, float b, char c, double d, int64 e) {};
+    API_FUNCTION() virtual void StringParamAnsi(StringAnsi str) {};
+    API_FUNCTION() virtual void StringParam(String str) {};
+    API_FUNCTION() virtual void StringParamRef(String& str) {};
+    API_FUNCTION() virtual void StringParamRefConst(const String& str) {};
+    API_FUNCTION() virtual void StringParamAsRef(API_PARAM(Ref) String& str) {};
+    API_FUNCTION() virtual void ActorParam(Actor* actor) {};
+    API_FUNCTION() virtual void ComplexParam(BehaviorUpdateContext context) {};
+    API_FUNCTION() virtual void Complex2Param(RenderContext& context) {};
+    API_FUNCTION() virtual void Complex2ParamConst(const RenderContext& context) {};
+    API_FUNCTION() virtual void Complex2ParamAsRef(API_PARAM(Ref) RenderContext& context) {};
+    API_FUNCTION() virtual void SimpleArrayParam(Array<int> arr) {};
+    API_FUNCTION() virtual void SimpleArrayParamRef(Array<int>& arr) {};
+    API_FUNCTION() virtual void SimpleArrayParamRefConst(const Array<int>& arr) {};
+    API_FUNCTION() virtual void SimpleArrayParamAsRef(API_PARAM(Ref) Array<int>& arr) {};
+    API_FUNCTION() virtual void ActorArrayParam(Array<Actor*> arr) {};
+    API_FUNCTION() virtual void ActorArrayParamRef(Array<Actor*>& arr) {};
+    API_FUNCTION() virtual void ActorArrayParamRefConst(const Array<Actor*>& arr) {};
+
+    //API_FUNCTION() virtual void ActorArrayParamAsRef(API_PARAM(Ref) Array<Actor*>& arr) {};
+
+    API_FUNCTION() virtual void ComplexArrayParam(Array<TestStruct> arr) {};
+    API_FUNCTION() virtual void ComplexArrayParamRef(Array<TestStruct>& arr) {};
+    API_FUNCTION() virtual void ComplexArrayParamRefConst(const Array<TestStruct>& arr) {};
+    API_FUNCTION() virtual void ComplexArrayParamAsRef(API_PARAM(Ref) Array<TestStruct>& arr) {};
+
+
+    //API_EVENT() Delegate<int32, Float3, const String&, String&, TestStruct&, const Array<TestStruct>&, Array<TestStruct>&> TestEvent;
+    
+};
+
+API_CLASS() class GAME_API MyScript : public Script
+{
+API_AUTO_SERIALIZATION();
+DECLARE_SCRIPTING_TYPE(MyScript);
+
+    /*API_STRUCT() struct GAME_API InnerStructer
+    {
+    public:
+        float floaty;
+    };*/
+
+    //API_FIELD() MyThinger<int> thingey;
+
+    // [Script]
+    void OnStart() override;
+    void OnEnable() override;
+    void OnDisable() override;
+    void OnUpdate() override;
+
+    API_FUNCTION() virtual void ManagedCoverageTests() {};
+    API_FUNCTION() virtual void CoverageTest1(int32 a, bool b, Actor* c, String& d, StringAnsi& e, Float3 f) {};
+    API_FUNCTION() virtual void CoverageTest1Array(Array<int32> a, Array<bool> b, Array<Actor*> c, Array<String> d, Array<StringAnsi> e, Array<Float3> f) {};
+    API_FUNCTION() virtual void CoverageTest1ByRef(API_PARAM(Ref) int32& a, API_PARAM(Ref) bool& b, API_PARAM(Ref) String& d, API_PARAM(Ref) StringAnsi& e, API_PARAM(Ref) Float3& f) {};
+    API_FUNCTION() virtual void CoverageTest1ArrayByRef(API_PARAM(Ref) Array<int32>& a, API_PARAM(Ref) Array<bool>& b, API_PARAM(Ref) Array<String>& d, API_PARAM(Ref) Array<StringAnsi>& e, API_PARAM(Ref) Array<Float3>& f) {};
+    API_FUNCTION() virtual void CoverageTest2(Guid a, AssetReference<FontAsset> b, Array<Guid> c, Array<AssetReference<FontAsset>> d) {};
+    API_FUNCTION() virtual void CoverageNamespaces1(NetworkChannelType a, Array<NetworkChannelType> b, OnlineLeaderboardSortModes c, Array<OnlineLeaderboardSortModes> d, OnlineLeaderboardValueFormats e, Array<OnlineLeaderboardValueFormats> f) {};
+
+
+    //API_FUNCTION() void Test1(API_PARAM(REF) Array<TestTypeEnum>& eenums) {};
+    //API_FUNCTION() BezierCurve<Transform>.Keyframe Test2(BezierCurve<Transform> kef) {};
+};
+
+#define LOG_TEST(FUNC) \
+if (thunkTests || invokeTests) LOG(Info, #FUNC);
+
+#define BENCHMARK_INVOKE_ARGS0(REPEAT, FUNC) \
+{ \
+    auto klass = MyScript2::GetStaticClass(); \
+    auto method = klass->GetMethod(#FUNC, 0); \
+    auto instance = scriptTwo->GetManagedInstance(); \
+    MObject* exception = nullptr; \
+    const auto times = REPEAT; \
+    const auto chunkTimes = CHUNK_TIMES; \
+    const auto freq = Platform::GetClockFrequency(); \
+    results.Clear(); \
+    auto start2 = Platform::GetTimeCycles(); \
+    for (int i = 0; i < times; ++i) \
+    { \
+        auto start = Platform::GetTimeCycles(); \
+        for (int j = 0; j < chunkTimes; ++j) \
+            method->Invoke(instance, nullptr, &exception); \
+        auto end = Platform::GetTimeCycles(); \
+        auto elapsed = end - start; \
+        results.Add(elapsed); \
+    } \
+    auto end2 = Platform::GetTimeCycles(); \
+    auto elapsed2 = end2 - start2; \
+    Sorting::MergeSort(results); \
+    const auto resultsIndex = 0; \
+    LOG(Info, "  - InvokeOnly: {:.1f}ns ({:.0f}ms total {} times)", (results[resultsIndex] * (1.0 / static_cast<double>(freq)) * 1000000000 / chunkTimes), (elapsed2 * (1.0 / static_cast<double>(freq)) * 1000), times*chunkTimes); \
+}
+#define BENCHMARK_INVOKE_ARGS1(REPEAT, FUNC, PARAM1) \
+void* params[1]; \
+{ \
+    auto klass = MyScript2::GetStaticClass(); \
+    auto method = klass->GetMethod(#FUNC, 1); \
+    auto instance = scriptTwo->GetManagedInstance(); \
+    MObject* exception = nullptr; \
+    const auto times = REPEAT; \
+    const auto chunkTimes = CHUNK_TIMES; \
+    const auto freq = Platform::GetClockFrequency(); \
+    params[0] = PARAM1; \
+    results.Clear(); \
+    auto start2 = Platform::GetTimeCycles(); \
+    for (int i = 0; i < times; ++i) \
+    { \
+        auto start = Platform::GetTimeCycles(); \
+        for (int j = 0; j < chunkTimes; ++j) \
+            method->Invoke(instance, params, &exception); \
+        auto end = Platform::GetTimeCycles(); \
+        auto elapsed = end - start; \
+        results.Add(elapsed); \
+    } \
+    auto end2 = Platform::GetTimeCycles(); \
+    auto elapsed2 = end2 - start2; \
+    Sorting::MergeSort(results); \
+    const auto resultsIndex = 0; \
+    LOG(Info, "  - InvokeOnly: {:.1f}ns ({:.0f}ms total {} times)", (results[resultsIndex] * (1.0 / static_cast<double>(freq)) * 1000000000 / chunkTimes), (elapsed2 * (1.0 / static_cast<double>(freq)) * 1000), times*chunkTimes); \
+}
+#define BENCHMARK_INVOKE_ARGS1_REF(REPEAT, FUNC, PARAM1, PARAM1_CLEAN) \
+{ \
+    auto const NUM_PARAMS = 1; \
+    auto klass = MyScript2::GetStaticClass(); \
+    auto method = klass->GetMethod(#FUNC, NUM_PARAMS); \
+    auto instance = scriptTwo->GetManagedInstance(); \
+    MObject* exception = nullptr; \
+    const auto times = REPEAT; \
+    const auto chunkTimes = CHUNK_TIMES; \
+    const auto freq = Platform::GetClockFrequency(); \
+    void* params[NUM_PARAMS]; \
+    params[0] = PARAM1; \
+    results.Clear(); \
+    auto start2 = Platform::GetTimeCycles(); \
+    for (int i = 0; i < times; ++i) \
+    { \
+        void* params_call[CHUNK_TIMES * NUM_PARAMS]; \
+        void* params_call_orig[CHUNK_TIMES * NUM_PARAMS]; \
+        for (int j = 0; j < chunkTimes * NUM_PARAMS; j += NUM_PARAMS) \
+        { \
+            params_call_orig[j+0] = params[0]; \
+            params_call[j+0] = &params_call_orig[j+0]; \
+        } \
+        auto start = Platform::GetTimeCycles(); \
+        for (int j = 0; j < chunkTimes; ++j) \
+        { \
+            method->Invoke(instance, &params_call[j * NUM_PARAMS], &exception); \
+        } \
+        auto end = Platform::GetTimeCycles(); \
+        auto elapsed = end - start; \
+        results.Add(elapsed); \
+        for (int j = 0; j < chunkTimes * NUM_PARAMS; j += NUM_PARAMS) \
+        { \
+            if (params_call_orig[j+0] != params[0]) \
+            { \
+                void* param = params_call_orig[j+0]; \
+                MUtils::FreeManaged<String>((MObject*)param); \
+            } \
+        } \
+    } \
+    auto end2 = Platform::GetTimeCycles(); \
+    auto elapsed2 = end2 - start2; \
+    Sorting::MergeSort(results); \
+    { \
+        void* param = params[0]; \
+        PARAM1_CLEAN((MObject*)param); \
+    } \
+    const auto resultsIndex = 0; \
+    LOG(Info, "  - InvokeOnly: {:.1f}ns ({:.0f}ms total {} times)", (results[resultsIndex] * (1.0 / static_cast<double>(freq)) * 1000000000 / chunkTimes), (elapsed2 * (1.0 / static_cast<double>(freq)) * 1000), times*chunkTimes); \
+}
+#define BENCHMARK_INVOKE_ARGS2(REPEAT, FUNC, PARAM1, PARAM2) \
+void* params[2]; \
+{ \
+    auto klass = MyScript2::GetStaticClass(); \
+    auto method = klass->GetMethod(#FUNC, 2); \
+    auto instance = scriptTwo->GetManagedInstance(); \
+    MObject* exception = nullptr; \
+    const auto times = REPEAT; \
+    const auto chunkTimes = CHUNK_TIMES; \
+    const auto freq = Platform::GetClockFrequency(); \
+    params[0] = PARAM1; \
+    params[1] = PARAM2; \
+    results.Clear(); \
+    auto start2 = Platform::GetTimeCycles(); \
+    for (int i = 0; i < times; ++i) \
+    { \
+        auto start = Platform::GetTimeCycles(); \
+        for (int j = 0; j < chunkTimes; ++j) \
+            method->Invoke(instance, params, &exception); \
+        auto end = Platform::GetTimeCycles(); \
+        auto elapsed = end - start; \
+        results.Add(elapsed); \
+    } \
+    auto end2 = Platform::GetTimeCycles(); \
+    auto elapsed2 = end2 - start2; \
+    Sorting::MergeSort(results); \
+    const auto resultsIndex = 0; \
+    LOG(Info, "  - InvokeOnly: {:.1f}ns ({:.0f}ms total {} times)", (results[resultsIndex] * (1.0 / static_cast<double>(freq)) * 1000000000 / chunkTimes), (elapsed2 * (1.0 / static_cast<double>(freq)) * 1000), times*chunkTimes); \
+}
+#define BENCHMARK_INVOKE_ARGS3(REPEAT, FUNC, PARAM1, PARAM2, PARAM3) \
+void* params[3]; \
+{ \
+    auto klass = MyScript2::GetStaticClass(); \
+    auto method = klass->GetMethod(#FUNC, 3); \
+    auto instance = scriptTwo->GetManagedInstance(); \
+    MObject* exception = nullptr; \
+    const auto times = REPEAT; \
+    const auto chunkTimes = CHUNK_TIMES; \
+    const auto freq = Platform::GetClockFrequency(); \
+    params[0] = PARAM1; \
+    params[1] = PARAM2; \
+    params[2] = PARAM3; \
+    results.Clear(); \
+    auto start2 = Platform::GetTimeCycles(); \
+    for (int i = 0; i < times; ++i) \
+    { \
+        auto start = Platform::GetTimeCycles(); \
+        for (int j = 0; j < chunkTimes; ++j) \
+            method->Invoke(instance, params, &exception); \
+        auto end = Platform::GetTimeCycles(); \
+        auto elapsed = end - start; \
+        results.Add(elapsed); \
+    } \
+    auto end2 = Platform::GetTimeCycles(); \
+    auto elapsed2 = end2 - start2; \
+    Sorting::MergeSort(results); \
+    const auto resultsIndex = 0; \
+    LOG(Info, "  - InvokeOnly: {:.1f}ns ({:.0f}ms total {} times)", (results[resultsIndex] * (1.0 / static_cast<double>(freq)) * 1000000000 / chunkTimes), (elapsed2 * (1.0 / static_cast<double>(freq)) * 1000), times*chunkTimes); \
+}
+#define BENCHMARK_INVOKE_ARGS4(REPEAT, FUNC, PARAM1, PARAM2, PARAM3, PARAM4) \
+void* params[4]; \
+{ \
+    auto klass = MyScript2::GetStaticClass(); \
+    auto method = klass->GetMethod(#FUNC, 4); \
+    auto instance = scriptTwo->GetManagedInstance(); \
+    MObject* exception = nullptr; \
+    const auto times = REPEAT; \
+    const auto chunkTimes = CHUNK_TIMES; \
+    const auto freq = Platform::GetClockFrequency(); \
+    params[0] = PARAM1; \
+    params[1] = PARAM2; \
+    params[2] = PARAM3; \
+    params[3] = PARAM4; \
+    results.Clear(); \
+    auto start2 = Platform::GetTimeCycles(); \
+    for (int i = 0; i < times; ++i) \
+    { \
+        auto start = Platform::GetTimeCycles(); \
+        for (int j = 0; j < chunkTimes; ++j) \
+            method->Invoke(instance, params, &exception); \
+        auto end = Platform::GetTimeCycles(); \
+        auto elapsed = end - start; \
+        results.Add(elapsed); \
+    } \
+    auto end2 = Platform::GetTimeCycles(); \
+    auto elapsed2 = end2 - start2; \
+    Sorting::MergeSort(results); \
+    const auto resultsIndex = 0; \
+    LOG(Info, "  - InvokeOnly: {:.1f}ns ({:.0f}ms total {} times)", (results[resultsIndex] * (1.0 / static_cast<double>(freq)) * 1000000000 / chunkTimes), (elapsed2 * (1.0 / static_cast<double>(freq)) * 1000), times*chunkTimes); \
+}
+#define BENCHMARK_INVOKE_ARGS5(REPEAT, FUNC, PARAM1, PARAM2, PARAM3, PARAM4, PARAM5) \
+void* params[5]; \
+{ \
+    auto klass = MyScript2::GetStaticClass(); \
+    auto method = klass->GetMethod(#FUNC, 5); \
+    auto instance = scriptTwo->GetManagedInstance(); \
+    MObject* exception = nullptr; \
+    const auto times = REPEAT; \
+    const auto chunkTimes = CHUNK_TIMES; \
+    const auto freq = Platform::GetClockFrequency(); \
+    params[0] = PARAM1; \
+    params[1] = PARAM2; \
+    params[2] = PARAM3; \
+    params[3] = PARAM4; \
+    params[4] = PARAM5; \
+    results.Clear(); \
+    auto start2 = Platform::GetTimeCycles(); \
+    for (int i = 0; i < times; ++i) \
+    { \
+        auto start = Platform::GetTimeCycles(); \
+        for (int j = 0; j < chunkTimes; ++j) \
+            method->Invoke(instance, params, &exception); \
+        auto end = Platform::GetTimeCycles(); \
+        auto elapsed = end - start; \
+        results.Add(elapsed); \
+    } \
+    auto end2 = Platform::GetTimeCycles(); \
+    auto elapsed2 = end2 - start2; \
+    Sorting::MergeSort(results); \
+    const auto resultsIndex = 0; \
+    LOG(Info, "  - InvokeOnly: {:.1f}ns ({:.0f}ms total {} times)", (results[resultsIndex] * (1.0 / static_cast<double>(freq)) * 1000000000 / chunkTimes), (elapsed2 * (1.0 / static_cast<double>(freq)) * 1000), times*chunkTimes); \
+}
+
+#define BENCHMARK_CALL_ARGS0(REPEAT, FUNC) \
+{ \
+    const auto times = REPEAT; \
+    const auto chunkTimes = CHUNK_TIMES; \
+    const auto freq = Platform::GetClockFrequency(); \
+    results.Clear(); \
+    auto start2 = Platform::GetTimeCycles(); \
+    for (int i = 0; i < times; ++i) \
+    { \
+        auto start = Platform::GetTimeCycles(); \
+        for (int j = 0; j < chunkTimes; ++j) \
+            scriptTwo->FUNC(); \
+        auto end = Platform::GetTimeCycles(); \
+        auto elapsed = end - start; \
+        results.Add(elapsed); \
+    } \
+    auto end2 = Platform::GetTimeCycles(); \
+    auto elapsed2 = end2 - start2; \
+    Sorting::MergeSort(results); \
+    const auto resultsIndex = 0; \
+    LOG(Info, "  - VirtualCall: {:.1f}ns ({:.0f}ms total {} times)", (results[resultsIndex] * (1.0 / static_cast<double>(freq)) * 1000000000 / chunkTimes), (elapsed2 * (1.0 / static_cast<double>(freq)) * 1000), times*chunkTimes); \
+}
+#define BENCHMARK_CALL_ARGS1(REPEAT, FUNC, PARAM1) \
+{ \
+    const auto times = REPEAT; \
+    const auto chunkTimes = CHUNK_TIMES; \
+    const auto freq = Platform::GetClockFrequency(); \
+    results.Clear(); \
+    auto start2 = Platform::GetTimeCycles(); \
+    for (int i = 0; i < times; ++i) \
+    { \
+        auto start = Platform::GetTimeCycles(); \
+        for (int j = 0; j < chunkTimes; ++j) \
+            scriptTwo->FUNC(PARAM1); \
+        auto end = Platform::GetTimeCycles(); \
+        auto elapsed = end - start; \
+        results.Add(elapsed); \
+    } \
+    auto end2 = Platform::GetTimeCycles(); \
+    auto elapsed2 = end2 - start2; \
+    Sorting::MergeSort(results); \
+    const auto resultsIndex = 0; \
+    LOG(Info, "  - VirtualCall: {:.1f}ns ({:.0f}ms total {} times)", (results[resultsIndex] * (1.0 / static_cast<double>(freq)) * 1000000000 / chunkTimes), (elapsed2 * (1.0 / static_cast<double>(freq)) * 1000), times*chunkTimes); \
+}
+#define BENCHMARK_CALL_ARGS1_REF(REPEAT, FUNC, PARAM1) \
+{ \
+    const auto times = REPEAT; \
+    const auto chunkTimes = CHUNK_TIMES; \
+    const auto freq = Platform::GetClockFrequency(); \
+    results.Clear(); \
+    auto start2 = Platform::GetTimeCycles(); \
+    for (int i = 0; i < times; ++i) \
+    { \
+        auto start = Platform::GetTimeCycles(); \
+        for (int j = 0; j < chunkTimes; ++j) \
+        { \
+            auto _param1_orig_value = PARAM1; \
+            scriptTwo->FUNC(_param1_orig_value); \
+        } \
+        auto end = Platform::GetTimeCycles(); \
+        auto elapsed = end - start; \
+        results.Add(elapsed); \
+    } \
+    auto end2 = Platform::GetTimeCycles(); \
+    auto elapsed2 = end2 - start2; \
+    Sorting::MergeSort(results); \
+    const auto resultsIndex = 0; \
+    LOG(Info, "  - VirtualCall: {:.1f}ns ({:.0f}ms total {} times)", (results[resultsIndex] * (1.0 / static_cast<double>(freq)) * 1000000000 / chunkTimes), (elapsed2 * (1.0 / static_cast<double>(freq)) * 1000), times*chunkTimes); \
+}
+#define BENCHMARK_CALL_ARGS5(REPEAT, FUNC, PARAM1, PARAM2, PARAM3, PARAM4, PARAM5) \
+{ \
+    const auto times = REPEAT; \
+    const auto chunkTimes = CHUNK_TIMES; \
+    const auto freq = Platform::GetClockFrequency(); \
+    results.Clear(); \
+    auto start2 = Platform::GetTimeCycles(); \
+    for (int i = 0; i < times; ++i) \
+    { \
+        auto start = Platform::GetTimeCycles(); \
+        for (int j = 0; j < chunkTimes; ++j) \
+            scriptTwo->FUNC(PARAM1, PARAM2, PARAM3, PARAM4, PARAM5); \
+        auto end = Platform::GetTimeCycles(); \
+        auto elapsed = end - start; \
+        results.Add(elapsed); \
+    } \
+    auto end2 = Platform::GetTimeCycles(); \
+    auto elapsed2 = end2 - start2; \
+    Sorting::MergeSort(results); \
+    const auto resultsIndex = 0; \
+    LOG(Info, "  - VirtualCall: {:.1f}ns ({:.0f}ms total {} times)", (results[resultsIndex] * (1.0 / static_cast<double>(freq)) * 1000000000 / chunkTimes), (elapsed2 * (1.0 / static_cast<double>(freq)) * 1000), times*chunkTimes); \
+}
+#define BENCHMARK_THUNK_BEGIN_ARGS0(REPEAT, FUNC) \
+{ \
+    const auto times = REPEAT; \
+    const auto chunkTimes = CHUNK_TIMES; \
+    typedef void (*Thunk)(void* instance, MObject** exception); \
+    const auto thunk = (Thunk)scriptTwo->GetClass()->GetMethod(#FUNC, 0)->GetThunk(); \
+    const auto instance = scriptTwo->GetOrCreateManagedInstance(); \
+    MObject* exception = nullptr;
+#define BENCHMARK_THUNK_CALL_ARGS0() \
+    const auto freq = Platform::GetClockFrequency(); \
+    results.Clear(); \
+    auto start2 = Platform::GetTimeCycles(); \
+    for (int i = 0; i < times; ++i) \
+    { \
+        auto start = Platform::GetTimeCycles(); \
+        for (int j = 0; j < chunkTimes; ++j) \
+            thunk(instance, &exception); \
+        auto end = Platform::GetTimeCycles(); \
+        auto elapsed = end - start; \
+        results.Add(elapsed); \
+    } \
+    auto end2 = Platform::GetTimeCycles(); \
+    auto elapsed2 = end2 - start2; \
+    Sorting::MergeSort(results); \
+    const auto resultsIndex = 0; \
+    LOG(Info, "  - InvokeThunkOnly: {:.1f}ns ({:.0f}ms total {} times)", (results[resultsIndex] * (1.0 / static_cast<double>(freq)) * 1000000000 / chunkTimes), (elapsed2 * (1.0 / static_cast<double>(freq)) * 1000), times*chunkTimes);
+#define BENCHMARK_THUNK_BEGIN_ARGS1(REPEAT, FUNC) \
+{ \
+    const auto times = REPEAT; \
+    const auto chunkTimes = CHUNK_TIMES; \
+    typedef void (*Thunk)(void* instance, void*, MObject** exception); \
+    const auto thunk = (Thunk)scriptTwo->GetClass()->GetMethod(#FUNC, 1)->GetThunk(); \
+    const auto instance = scriptTwo->GetOrCreateManagedInstance(); \
+    MObject* exception = nullptr; \
+    void* params[1];
+#define BENCHMARK_THUNK_CALL_ARGS1() \
+    const auto freq = Platform::GetClockFrequency(); \
+    results.Clear(); \
+    auto start2 = Platform::GetTimeCycles(); \
+    for (int i = 0; i < times; ++i) \
+    { \
+        auto start = Platform::GetTimeCycles(); \
+        for (int j = 0; j < chunkTimes; ++j) \
+            thunk(instance, params[0], &exception); \
+        auto end = Platform::GetTimeCycles(); \
+        auto elapsed = end - start; \
+        results.Add(elapsed); \
+    } \
+    auto end2 = Platform::GetTimeCycles(); \
+    auto elapsed2 = end2 - start2; \
+    Sorting::MergeSort(results); \
+    const auto resultsIndex = 0; \
+    LOG(Info, "  - InvokeThunkOnly: {:.1f}ns ({:.0f}ms total {} times)", (results[resultsIndex] * (1.0 / static_cast<double>(freq)) * 1000000000 / chunkTimes), (elapsed2 * (1.0 / static_cast<double>(freq)) * 1000), times*chunkTimes);
+#define BENCHMARK_THUNK_CALL_ARGS1_REF(FUN) \
+    const auto freq = Platform::GetClockFrequency(); \
+    results.Clear(); \
+    auto start2 = Platform::GetTimeCycles(); \
+    for (int i = 0; i < times; ++i) \
+    { \
+        auto start = Platform::GetTimeCycles(); \
+        for (int j = 0; j < chunkTimes; ++j) \
+        { \
+            thunk(instance, params[0], &exception); \
+            FUN \
+        } \
+        auto end = Platform::GetTimeCycles(); \
+        auto elapsed = end - start; \
+        results.Add(elapsed); \
+    } \
+    auto end2 = Platform::GetTimeCycles(); \
+    auto elapsed2 = end2 - start2; \
+    Sorting::MergeSort(results); \
+    const auto resultsIndex = 0; \
+    LOG(Info, "  - InvokeThunkOnly: {:.1f}ns ({:.0f}ms total {} times)", (results[resultsIndex] * (1.0 / static_cast<double>(freq)) * 1000000000 / chunkTimes), (elapsed2 * (1.0 / static_cast<double>(freq)) * 1000), times*chunkTimes);
+#define BENCHMARK_THUNK_BEGIN_ARGS5(REPEAT, FUNC) \
+{ \
+    const auto times = REPEAT; \
+    const auto chunkTimes = CHUNK_TIMES; \
+    typedef void (*Thunk)(void* instance, void*, void*, void*, void*, void*, MObject** exception); \
+    const auto thunk = (Thunk)scriptTwo->GetClass()->GetMethod(#FUNC, 5)->GetThunk(); \
+    const auto instance = scriptTwo->GetOrCreateManagedInstance(); \
+    MObject* exception = nullptr; \
+    void* params[5];
+#define BENCHMARK_THUNK_CALL_ARGS5() \
+    const auto freq = Platform::GetClockFrequency(); \
+    results.Clear(); \
+    auto start2 = Platform::GetTimeCycles(); \
+    for (int i = 0; i < times; ++i) \
+    { \
+        auto start = Platform::GetTimeCycles(); \
+        for (int j = 0; j < chunkTimes; ++j) \
+            thunk(instance, params[0], params[1], params[2], params[3], params[4], &exception); \
+        auto end = Platform::GetTimeCycles(); \
+        auto elapsed = end - start; \
+        results.Add(elapsed); \
+    } \
+    auto end2 = Platform::GetTimeCycles(); \
+    auto elapsed2 = end2 - start2; \
+    Sorting::MergeSort(results); \
+    const auto resultsIndex = 0; \
+    LOG(Info, "  - InvokeThunkOnly: {:.1f}ns ({:.0f}ms total {} times)", (results[resultsIndex] * (1.0 / static_cast<double>(freq)) * 1000000000 / chunkTimes), (elapsed2 * (1.0 / static_cast<double>(freq)) * 1000), times*chunkTimes);
+#define BENCHMARK_THUNK_END() \
+}
+#define COVERAGE_CALL_ARGS2(FUNC, PARAM1, PARAM2) \
+{ \
+    LOG(Info, #FUNC); \
+    scriptTwo->FUNC(PARAM1, PARAM2); \
+}
+#define COVERAGE_CALL_ARGS3(FUNC, PARAM1, PARAM2, PARAM3) \
+{ \
+    LOG(Info, #FUNC); \
+    scriptTwo->FUNC(PARAM1, PARAM2, PARAM3); \
+}
+#define COVERAGE_CALL_ARGS4(FUNC, PARAM1, PARAM2, PARAM3, PARAM4) \
+{ \
+    LOG(Info, #FUNC); \
+    scriptTwo->FUNC(PARAM1, PARAM2, PARAM3, PARAM4); \
+}
+#define COVERAGE_CALL_ARGS5(FUNC, PARAM1, PARAM2, PARAM3, PARAM4, PARAM5) \
+{ \
+    LOG(Info, #FUNC); \
+    scriptTwo->FUNC(PARAM1, PARAM2, PARAM3, PARAM4, PARAM5); \
+}
+#define COVERAGE_CALL_ARGS6(FUNC, PARAM1, PARAM2, PARAM3, PARAM4, PARAM5, PARAM6) \
+{ \
+    LOG(Info, #FUNC); \
+    scriptTwo->FUNC(PARAM1, PARAM2, PARAM3, PARAM4, PARAM5, PARAM6); \
+}

Source/Game/MyScriptTwo.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using FlaxEngine;
+using FlaxEngine.Interop;
+using FlaxEngine.Networking;
+using FlaxEngine.Online;
+
+namespace Game;
+
+/// <summary>
+/// MyScriptTwo Script.
+/// </summary>
+public class MyScriptTwo : MyScript2
+{
+    private int counter = 0;
+    /// <inheritdoc/>
+    public override void OnStart()
+    {
+        Debug.Log("C# OnStart");
+    }
+    
+    /// <inheritdoc/>
+    public override void OnEnable()
+    {
+        //counter++;
+    }
+
+    /// <inheritdoc/>
+    public override void OnDisable()
+    {
+    }
+
+    /// <inheritdoc/>
+    public override void OnUpdate()
+    {
+    }
+
+    public override void GetStats(ref long allocations, ref long deallocations)
+    {
+        allocations = ManagedHandle.Allocations;
+        deallocations = ManagedHandle.Deallocations;
+    }
+
+    public override void ManagedCoverageTests()
+    {
+        Debug.LogWarning("ManagedCoverageTests");
+        Actor actor = this.Actor;
+        MyScript script = actor.GetScript<MyScript>();
+
+        string shortString = "Testing string parameter marshalling";
+        Float3 f3 = new Float3(1, 2, 3);
+
+
+        if (true)
+        {
+            int[] ints = { 1 };
+            bool[] booleans = { true };
+            Actor[] actors = { actor };
+            string[] strings = { shortString };
+            Float3[] float3s = { f3 };
+
+            script.CoverageTest1(1, true, actor, shortString, shortString, f3);
+            script.CoverageTest1Array(ints, booleans, actors, strings, strings, float3s);
+            script.CoverageTest1ByRef(ref ints[0], ref booleans[0]/*, ref actors[0]*/, ref strings[0], ref strings[0], ref float3s[0]);
+            script.CoverageTest1ArrayByRef(ref ints, ref booleans/*, ref actors*/, ref strings, ref strings, ref float3s);
+            //script.CoverageTest2(fontAssetGuid, fontAssetRef, Array<Guid>(&fontAssetGuid, 1), Array<AssetReference<FontAsset>>(&fontAssetRef, 1));
+            //script.CoverageNamespaces1(networkChannelType, Array<NetworkChannelType>(&networkChannelType, 1), onlineLeaderboardSortModes, Array<OnlineLeaderboardSortModes>(&onlineLeaderboardSortModes, 1), onlineLeaderboardValueFormats, Array<OnlineLeaderboardValueFormats>(&onlineLeaderboardValueFormats, 1));
+        }
+    }
+
+    public override void CoverageTest1(int a, bool b, Actor c, String d, String e, Float3 f) {}
+    public override void CoverageTest1Array(int[] a, bool[] b, Actor[] c, String[] d, String[] e, Float3[] f) {}
+    public override void CoverageTest1ByRef(ref int a, ref bool b/*, ref Actor c*/, ref String d, ref String e, ref Float3 f) {}
+    public override void CoverageTest1ArrayByRef(ref int[] a, ref bool[] b/*, ref Actor[] c*/, ref String[] d, ref String[] e, ref Float3[] f) {}
+    public override void CoverageTest2(Guid a, FontAsset b, Guid[] c, FontAsset[] d) {}
+    public override void CoverageTest3(ModelLOD a, out ModelLOD[] b) { b = null; }
+    public override void CoverageNamespaces1(NetworkChannelType a, NetworkChannelType[] b, OnlineLeaderboardSortModes c, OnlineLeaderboardSortModes[] d, OnlineLeaderboardValueFormats e, OnlineLeaderboardValueFormats[] f) {}
+
+    public override void SimpleCall() {}
+    public override void SimpleParams(int a, float b, sbyte c, double d, long e) {}
+    public override void StringParamAnsi(string str) {}
+    public override void StringParam(string str) {}
+    public override void StringParamRef(string str) {}
+    public override void StringParamRefConst(string str) {}
+    public override void StringParamAsRef(ref string str) {}
+    public override void ActorParam(Actor actor) {}
+    public override void ComplexParam(BehaviorUpdateContext context) {}
+    public override void Complex2Param(RenderContext context) {}
+    public override void Complex2ParamConst(RenderContext context) {}
+    public override void Complex2ParamAsRef(ref RenderContext context) {}
+    public override void SimpleArrayParam(int[] arr) {}
+    public override void SimpleArrayParamRef(int[] arr) {}
+    public override void SimpleArrayParamRefConst(int[] arr) {}
+    public override void SimpleArrayParamAsRef(ref int[] arr) {}
+    public override void ActorArrayParam(Actor[] arr) {}
+    public override void ActorArrayParamRef(Actor[] arr) {}
+    public override void ActorArrayParamRefConst(Actor[] arr) {}
+    //public override void ActorArrayParamAsRef(ref Actor[] arr) {}
+    public override void ComplexArrayParam(TestStruct[] arr) {}
+    public override void ComplexArrayParamRef(TestStruct[] arr) {}
+    public override void ComplexArrayParamRefConst(TestStruct[] arr) {}
+    public override void ComplexArrayParamAsRef(ref TestStruct[] arr) {}
+}

Source/GameTarget.Build.cs

@@ -24,13 +24,16 @@ public class GameTarget : GameProjectTarget
             OutputType = TargetOutputType.Executable;
         }
         Modules.Add("Game");
+        Modules.Add("Graphics");
     }
 
     public override void SetupTargetEnvironment(BuildOptions options)
     {
         base.SetupTargetEnvironment(options);
 
+#pragma warning disable CS0618 // X is obsolete
         options.LinkEnv.UseFastPDBLinking = true;
+#pragma warning restore CS0618 // X is obsolete
     }
 
     public override string GetOutputFilePath(BuildOptions options, TargetOutputType? outputType = null)