diff --git a/develop/unbench/invoke_function_bench.cpp b/develop/unbench/invoke_function_bench.cpp
index 46fbdff..2d58ef2 100644
--- a/develop/unbench/invoke_function_bench.cpp
+++ b/develop/unbench/invoke_function_bench.cpp
@@ -5,10 +5,12 @@
  ******************************************************************************/
 
 #include <meta.hpp/meta_all.hpp>
+#include <vmath.hpp/vmath_all.hpp>
+
+#include <rttr/type>
+#include <rttr/registration>
 
 #include <benchmark/benchmark.h>
-#include <rttr/registration>
-#include <vmath.hpp/vmath_all.hpp>
 
 namespace
 {
@@ -18,89 +20,161 @@ namespace
     float static_angle{};
     volatile float static_acc{};
 
-    struct clazz {
-        static void static_function0() {
-            static_acc = static_acc + vmath::determinant(vmath::rotate(static_angle, vmath::unit3_x<float>));
-            static_angle = static_angle + 0.00001f;
-        }
+    void static_function_0() {
+        static_acc = static_acc + vmath::determinant(vmath::rotate(static_angle, vmath::unit3_x<float>));
+        static_angle = static_angle + 0.00001f;
+    }
 
-        static void static_function1(float angle) {
-            static_acc = static_acc + vmath::determinant(vmath::rotate(angle, vmath::unit3_x<float>));
-            static_angle = static_angle + 0.00001f;
-        }
+    void static_function_1(float angle) {
+        static_acc = static_acc + vmath::determinant(vmath::rotate(angle, vmath::unit3_x<float>));
+        static_angle = static_angle + 0.00001f;
+    }
 
-        static void static_function2(float angle, const vmath::fvec3& axis) {
-            static_acc = static_acc + vmath::determinant(vmath::rotate(angle, axis));
-            static_angle = static_angle + 0.00001f;
-        }
+    void static_function_2(float angle, const vmath::fvec3& axis) {
+        static_acc = static_acc + vmath::determinant(vmath::rotate(angle, axis));
+        static_angle = static_angle + 0.00001f;
+    }
 
-        static void static_function3(float angle, const vmath::fvec3& axis, float mul) {
-            static_acc = static_acc + vmath::determinant(vmath::rotate(angle, axis)) * mul;
-            static_angle = static_angle + 0.00001f;
-        }
-    };
+    void static_function_3(float angle, const vmath::fvec3& axis, float mul) {
+        static_acc = static_acc + vmath::determinant(vmath::rotate(angle, axis)) * mul;
+        static_angle = static_angle + 0.00001f;
+    }
 
-    void invoke_function_reset(const benchmark::State&) {
+    void static_function_4(float angle, const vmath::fvec3& axis, float mul, const vmath::fmat3& mat) {
+        static_acc = static_acc + vmath::determinant(vmath::rotate(angle, axis) * mat) * mul;
+        static_angle = static_angle + 0.00001f;
+    }
+
+    void static_function_reset(const benchmark::State&) {
         static_acc = 0.f;
         static_angle = 0.f;
     }
 
-    // native
+    meta::scope meta_bench_scope = meta::local_scope_("")
+        .function_("static_function_0", &static_function_0)
+        .function_("static_function_1", &static_function_1)
+        .function_("static_function_2", &static_function_2)
+        .function_("static_function_3", &static_function_3)
+        .function_("static_function_4", &static_function_4);
+}
 
+RTTR_REGISTRATION
+{
+    using namespace rttr;
+
+    registration::method("static_function_0", &static_function_0);
+    registration::method("static_function_1", &static_function_1);
+    registration::method("static_function_2", &static_function_2);
+    registration::method("static_function_3", &static_function_3);
+    registration::method("static_function_4", &static_function_4);
+}
+
+//
+// native
+//
+
+namespace
+{
+    [[maybe_unused]]
     void invoke_function_0(benchmark::State &state) {
         for ( auto _ : state ) {
-            clazz::static_function0();
+            static_function_0();
         }
     }
 
+    [[maybe_unused]]
     void invoke_function_1(benchmark::State &state) {
         for ( auto _ : state ) {
-            clazz::static_function1(static_angle);
+            static_function_1(static_angle);
         }
     }
 
+    [[maybe_unused]]
     void invoke_function_2(benchmark::State &state) {
         for ( auto _ : state ) {
-            clazz::static_function2(static_angle, vmath::unit3_x<float>);
+            static_function_2(static_angle, vmath::unit3_x<float>);
         }
     }
 
+    [[maybe_unused]]
     void invoke_function_3(benchmark::State &state) {
         for ( auto _ : state ) {
-            clazz::static_function3(static_angle, vmath::unit3_x<float>, 2.f);
+            static_function_3(static_angle, vmath::unit3_x<float>, 2.f);
         }
     }
 
-    // meta
+    [[maybe_unused]]
+    void invoke_function_4(benchmark::State &state) {
+        for ( auto _ : state ) {
+            static_function_4(static_angle, vmath::unit3_x<float>, 2.f, vmath::midentity3<float>);
+        }
+    }
+}
 
+//
+// meta
+//
+
+namespace
+{
+    [[maybe_unused]]
     void meta_invoke_function_0(benchmark::State &state) {
+        meta::function f = meta_bench_scope.get_function("static_function_0");
         for ( auto _ : state ) {
-            meta::invoke(&clazz::static_function0);
+            f();
         }
     }
 
+    [[maybe_unused]]
     void meta_invoke_function_1(benchmark::State &state) {
+        meta::function f = meta_bench_scope.get_function("static_function_1");
+        META_HPP_ASSERT(f.is_valid());
+
         for ( auto _ : state ) {
-            meta::invoke(&clazz::static_function1, static_angle);
+            f(static_angle);
         }
     }
 
+    [[maybe_unused]]
     void meta_invoke_function_2(benchmark::State &state) {
+        meta::function f = meta_bench_scope.get_function("static_function_2");
+        META_HPP_ASSERT(f.is_valid());
+
         for ( auto _ : state ) {
-            meta::invoke(&clazz::static_function2, static_angle, vmath::unit3_x<float>);
+            f(static_angle, vmath::unit3_x<float>);
         }
     }
 
+    [[maybe_unused]]
     void meta_invoke_function_3(benchmark::State &state) {
+        meta::function f = meta_bench_scope.get_function("static_function_3");
+        META_HPP_ASSERT(f.is_valid());
+
         for ( auto _ : state ) {
-            meta::invoke(&clazz::static_function3, static_angle, vmath::unit3_x<float>, 2.f);
+            f(static_angle, vmath::unit3_x<float>, 2.f);
         }
     }
 
-    // rttr
+    [[maybe_unused]]
+    void meta_invoke_function_4(benchmark::State &state) {
+        meta::function f = meta_bench_scope.get_function("static_function_4");
+        META_HPP_ASSERT(f.is_valid());
 
+        for ( auto _ : state ) {
+            f(static_angle, vmath::unit3_x<float>, 2.f, vmath::midentity3<float>);
+        }
+    }
+}
+
+//
+// rttr
+//
+
+namespace
+{
+    [[maybe_unused]]
     void rttr_invoke_function_0(benchmark::State &state) {
-        rttr::method m = rttr::type::get_global_method("rttr_invoke_function_0");
+        rttr::method m = rttr::type::get_global_method("static_function_0");
         META_HPP_ASSERT(m.is_valid());
 
         for ( auto _ : state ) {
@@ -108,8 +182,9 @@ namespace
         }
     }
 
+    [[maybe_unused]]
     void rttr_invoke_function_1(benchmark::State &state) {
-        rttr::method m = rttr::type::get_global_method("rttr_invoke_function_1");
+        rttr::method m = rttr::type::get_global_method("static_function_1");
         META_HPP_ASSERT(m.is_valid());
 
         for ( auto _ : state ) {
@@ -117,8 +192,9 @@ namespace
         }
     }
 
+    [[maybe_unused]]
     void rttr_invoke_function_2(benchmark::State &state) {
-        rttr::method m = rttr::type::get_global_method("rttr_invoke_function_2");
+        rttr::method m = rttr::type::get_global_method("static_function_2");
         META_HPP_ASSERT(m.is_valid());
 
         for ( auto _ : state ) {
@@ -126,37 +202,43 @@ namespace
         }
     }
 
+    [[maybe_unused]]
     void rttr_invoke_function_3(benchmark::State &state) {
-        rttr::method m = rttr::type::get_global_method("rttr_invoke_function_3");
+        rttr::method m = rttr::type::get_global_method("static_function_3");
         META_HPP_ASSERT(m.is_valid());
 
         for ( auto _ : state ) {
             m.invoke({}, static_angle, vmath::unit3_x<float>, 2.f);
         }
     }
+
+    [[maybe_unused]]
+    void rttr_invoke_function_4(benchmark::State &state) {
+        rttr::method m = rttr::type::get_global_method("static_function_4");
+        META_HPP_ASSERT(m.is_valid());
+
+        for ( auto _ : state ) {
+            m.invoke({}, static_angle, vmath::unit3_x<float>, 2.f, vmath::midentity3<float>);
+        }
+    }
 }
 
-RTTR_REGISTRATION
-{
-    using namespace rttr;
-    registration::method("rttr_invoke_function_0", &clazz::static_function0);
-    registration::method("rttr_invoke_function_1", &clazz::static_function1);
-    registration::method("rttr_invoke_function_2", &clazz::static_function2);
-    registration::method("rttr_invoke_function_3", &clazz::static_function3);
-}
+BENCHMARK(invoke_function_0)->Teardown(static_function_reset);
+BENCHMARK(meta_invoke_function_0)->Teardown(static_function_reset);
+BENCHMARK(rttr_invoke_function_0)->Teardown(static_function_reset);
 
-BENCHMARK(invoke_function_0)->Teardown(invoke_function_reset);
-BENCHMARK(meta_invoke_function_0)->Teardown(invoke_function_reset);
-BENCHMARK(rttr_invoke_function_0)->Teardown(invoke_function_reset);
+BENCHMARK(invoke_function_1)->Teardown(static_function_reset);
+BENCHMARK(meta_invoke_function_1)->Teardown(static_function_reset);
+BENCHMARK(rttr_invoke_function_1)->Teardown(static_function_reset);
 
-BENCHMARK(invoke_function_1)->Teardown(invoke_function_reset);
-BENCHMARK(meta_invoke_function_1)->Teardown(invoke_function_reset);
-BENCHMARK(rttr_invoke_function_1)->Teardown(invoke_function_reset);
+BENCHMARK(invoke_function_2)->Teardown(static_function_reset);
+BENCHMARK(meta_invoke_function_2)->Teardown(static_function_reset);
+BENCHMARK(rttr_invoke_function_2)->Teardown(static_function_reset);
 
-BENCHMARK(invoke_function_2)->Teardown(invoke_function_reset);
-BENCHMARK(meta_invoke_function_2)->Teardown(invoke_function_reset);
-BENCHMARK(rttr_invoke_function_2)->Teardown(invoke_function_reset);
+BENCHMARK(invoke_function_3)->Teardown(static_function_reset);
+BENCHMARK(meta_invoke_function_3)->Teardown(static_function_reset);
+BENCHMARK(rttr_invoke_function_3)->Teardown(static_function_reset);
 
-BENCHMARK(invoke_function_3)->Teardown(invoke_function_reset);
-BENCHMARK(meta_invoke_function_3)->Teardown(invoke_function_reset);
-BENCHMARK(rttr_invoke_function_3)->Teardown(invoke_function_reset);
+BENCHMARK(invoke_function_4)->Teardown(static_function_reset);
+BENCHMARK(meta_invoke_function_4)->Teardown(static_function_reset);
+BENCHMARK(rttr_invoke_function_4)->Teardown(static_function_reset);