diff --git a/include/icamera.h b/include/icamera.h
index 98f13e58..3dda5386 100644
--- a/include/icamera.h
+++ b/include/icamera.h
@@ -28,7 +28,7 @@
 #pragma once
 
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 class Matrix4;
 
diff --git a/include/ifilesystem.h b/include/ifilesystem.h
index 5ec621a5..e87687f6 100644
--- a/include/ifilesystem.h
+++ b/include/ifilesystem.h
@@ -23,7 +23,7 @@
 
 #include <cstddef>
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 typedef Callback1<const char*> ArchiveNameCallback;
 typedef Callback1<const char*> FileNameCallback;
diff --git a/include/irender.h b/include/irender.h
index 49589941..9cdd73c3 100644
--- a/include/irender.h
+++ b/include/irender.h
@@ -22,7 +22,7 @@
 #pragma once
 
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 #include "generic/vector.h"
 
 
diff --git a/include/iselection.h b/include/iselection.h
index 09bb5ed6..6804abe1 100644
--- a/include/iselection.h
+++ b/include/iselection.h
@@ -23,7 +23,7 @@
 
 #include <cstddef>
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 #include "signal/signalfwd.h"
 
 class Renderer;
diff --git a/include/ishaders.h b/include/ishaders.h
index 7ab5ac43..07ad4004 100644
--- a/include/ishaders.h
+++ b/include/ishaders.h
@@ -22,7 +22,7 @@
 #pragma once
 
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 enum
 {
diff --git a/include/iundo.h b/include/iundo.h
index 050bb241..b5ec00d8 100644
--- a/include/iundo.h
+++ b/include/iundo.h
@@ -26,7 +26,7 @@
 
 #include <cstddef>
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 class UndoMemento
 {
diff --git a/include/mapfile.h b/include/mapfile.h
index d20a957e..db3d4831 100644
--- a/include/mapfile.h
+++ b/include/mapfile.h
@@ -24,7 +24,7 @@
 #include <limits>
 
 #include "iscenegraph.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 const std::size_t MAPFILE_MAX_CHANGES = std::numeric_limits<std::size_t>::max();
 
diff --git a/include/modelskin.h b/include/modelskin.h
index 68ab79d0..a08c95b2 100644
--- a/include/modelskin.h
+++ b/include/modelskin.h
@@ -22,7 +22,7 @@
 #pragma once
 
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 class SkinRemap
 {
diff --git a/include/nameable.h b/include/nameable.h
index 856352a2..f357b388 100644
--- a/include/nameable.h
+++ b/include/nameable.h
@@ -22,7 +22,7 @@
 #pragma once
 
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 typedef Callback1<const char*> NameCallback;
 
diff --git a/include/namespace.h b/include/namespace.h
index 1301d63f..7f515fbd 100644
--- a/include/namespace.h
+++ b/include/namespace.h
@@ -22,7 +22,7 @@
 #pragma once
 
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 typedef Callback1<const char*> NameCallback;
 typedef Callback1<const NameCallback&> NameCallbackCallback;
diff --git a/include/preferencesystem.h b/include/preferencesystem.h
index 64b2ccb9..ac2cde31 100644
--- a/include/preferencesystem.h
+++ b/include/preferencesystem.h
@@ -22,7 +22,7 @@
 #pragma once
 
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 typedef Callback1<const char*> StringImportCallback;
 typedef Callback1<const StringImportCallback&> StringExportCallback;
diff --git a/include/selectable.h b/include/selectable.h
index 92f7dcf9..b7905b99 100644
--- a/include/selectable.h
+++ b/include/selectable.h
@@ -25,7 +25,7 @@
 
 #include "generic/vector.h"
 #include "scenelib.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 class SelectionIntersection
 {
diff --git a/libs/generic/callback.h b/libs/generic/callback.h
index d5c96715..12e3b0c3 100644
--- a/libs/generic/callback.h
+++ b/libs/generic/callback.h
@@ -26,7 +26,6 @@
 
 #include <cstddef>
 #include "functional.h"
-#include "callbackfwd.h"
 
 template<typename Type>
 inline void* convertToOpaque( Type* t ){
@@ -150,6 +149,9 @@ public:
 template<class Caller>
 using BindFirstOpaque = BindFirstOpaqueN<Caller, get_func<Caller>>;
 
+/// \brief Combines a void pointer with a pointer to a function which operates on a void pointer.
+///
+/// Use with the callback constructors MemberCaller, ConstMemberCaller, ReferenceCaller, ConstReferenceCaller, PointerCaller, ConstPointerCaller and FreeCaller.
 template<class F>
 class CallbackN;
 
@@ -179,269 +181,214 @@ public:
 	}
 };
 
-/// \brief Combines a void pointer with a pointer to a function which operates on a void pointer.
-///
-/// Use with the callback constructors MemberCaller, ConstMemberCaller, ReferenceCaller, ConstReferenceCaller, PointerCaller, ConstPointerCaller and FreeCaller.
-template<class Result>
-class Callback0 : public CallbackN<Result()>
-{
-public:
-	using CallbackN<Result()>::CallbackN;
-};
+namespace detail {
+	template<class F>
+	struct Arglist;
 
-template<typename Caller>
-inline Callback0<get_result_type<Caller>> makeCallback0( const Caller& caller, get_argument<Caller, 0> callee ){
-	return Callback0<get_result_type<Caller>>( BindFirstOpaque<Caller>( callee ) );
-}
-template<typename Caller>
-inline Callback0<get_result_type<Caller>> makeStatelessCallback0( const Caller& caller ){
-	return makeCallback0( Caller0To1<Caller>(), 0 );
+	template<class R, class Head, class... Ts>
+	struct Arglist<R(Head, Ts...)>
+	{
+		using type = R(Head, Ts...);
+
+		template <class Unshift>
+		using unshift = Arglist<R(Unshift, Head, Ts...)>;
+
+		using shift = Arglist<R(Ts...)>;
+	};
+
+	template<class R, class... Ts>
+	struct Arglist<R(Ts...)>
+	{
+		using type = R(Ts...);
+
+		template <class Unshift>
+		using unshift = Arglist<R(Unshift, Ts...)>;
+	};
 }
 
-typedef Callback0<void> Callback;
-
-
-
-/// \brief Combines a void pointer with a pointer to a function which operates on a void pointer and one other argument.
-///
-/// Use with the callback constructors MemberCaller1, ConstMemberCaller1, ReferenceCaller1, ConstReferenceCaller1, PointerCaller1, ConstPointerCaller1 and FreeCaller1.
-template<class FirstArgument, class Result>
-class Callback1 : public CallbackN<Result(FirstArgument)>
-{
-public:
-	using CallbackN<Result(FirstArgument)>::CallbackN;
-};
-
 template<typename Caller>
-inline Callback1<get_argument<Caller, 1>, get_result_type<Caller>>
-makeCallback1( const Caller& caller, get_argument<Caller, 0> callee ){
-	return Callback1<get_argument<Caller, 1>, get_result_type<Caller>>( BindFirstOpaque<Caller>( callee ) );
-}
-template<typename Caller>
-inline Callback1<get_argument<Caller, 1>, get_result_type<Caller>> makeStatelessCallback1( const Caller& caller ){
-	return makeCallback1( Caller1To2<Caller>(), 0 );
+inline CallbackN<typename detail::Arglist<get_func<Caller>>::shift::type> makeCallbackN( const Caller& caller, get_argument<Caller, 0> callee ){
+	return CallbackN<typename detail::Arglist<get_func<Caller>>::shift::type>( BindFirstOpaque<Caller>( callee ) );
 }
 
-
-/// \brief Combines a void pointer with a pointer to a function which operates on a void pointer and two other arguments.
-///
-template<typename FirstArgument, typename SecondArgument, typename Result>
-class Callback2 : public CallbackN<Result(FirstArgument, SecondArgument)>
-{
-public:
-	using CallbackN<Result(FirstArgument, SecondArgument)>::CallbackN;
-};
-
 template<typename Caller>
-inline Callback2<
-         get_argument<Caller, 1>,
-         get_argument<Caller, 2>,
-         get_result_type<Caller>
-> makeCallback2( const Caller& caller, get_argument<Caller, 0> callee ){
-	return Callback2<
-	           get_argument<Caller, 1>,
-	           get_argument<Caller, 2>,
-	           get_result_type<Caller>
-	       >( BindFirstOpaque<Caller>( callee ) );
-}
-template<typename Caller>
-inline Callback2<
-         get_argument<Caller, 0>,
-         get_argument<Caller, 1>,
-         get_result_type<Caller>
-> makeStatelessCallback2( const Caller& caller){
-	return makeCallback2( Caller2To3<Caller>(), 0 );
+inline CallbackN<get_func<Caller>> makeStatelessCallbackN( const Caller& caller ){
+	return makeCallbackN( CallerShiftFirst<Caller, typename detail::Arglist<get_func<Caller>>::template unshift<void *>::type>(), nullptr );
 }
 
+namespace detail {
+	template<class Object, class F>
+	struct MemberFunction;
 
-/// \brief Combines a void pointer with a pointer to a function which operates on a void pointer and three other arguments.
-///
-template<typename FirstArgument, typename SecondArgument, typename ThirdArgument, typename Result>
-class Callback3 : public CallbackN<Result(FirstArgument, SecondArgument, ThirdArgument)>
-{
-public:
-	using CallbackN<Result(FirstArgument, SecondArgument, ThirdArgument)>::CallbackN;
-};
-
-template<typename Caller>
-inline Callback3<
-         get_argument<Caller, 1>,
-         get_argument<Caller, 2>,
-         get_argument<Caller, 3>,
-         get_result_type<Caller>
-> makeCallback3( const Caller& caller, get_argument<Caller, 0> callee ){
-	return Callback3<
-	            get_argument<Caller, 1>,
-	            get_argument<Caller, 2>,
-	            get_argument<Caller, 3>,
-	            get_result_type<Caller>
-	       >( BindFirstOpaque<Caller>( callee ) );
-}
-template<typename Caller>
-inline Callback3<
-         get_argument<Caller, 0>,
-         get_argument<Caller, 1>,
-         get_argument<Caller, 2>,
-         get_result_type<Caller>
-> makeStatelessCallback3( const Caller& caller ){
-	return makeCallback3( Caller3To4<Caller>(), 0 );
+	template<class Object, class R, class... Ts>
+	struct MemberFunction<Object, R(Ts...)>
+	{
+		using type = R(Object::*)(Ts...);
+		using type_const = R(Object::*)(Ts...) const;
+	};
 }
 
+template<class Object, class F>
+using MemberFunction = typename detail::MemberFunction<Object, F>::type;
 
-/// \brief Combines a void pointer with a pointer to a function which operates on a void pointer and four other arguments.
-///
-template<typename FirstArgument, typename SecondArgument, typename ThirdArgument, typename FourthArgument, typename Result>
-class Callback4 : public CallbackN<Result(FirstArgument, SecondArgument, ThirdArgument, FourthArgument)>
-{
-public:
-	using CallbackN<Result(FirstArgument, SecondArgument, ThirdArgument, FourthArgument)>::CallbackN;
-};
-
-template<typename Caller>
-inline Callback4<
-         get_argument<Caller, 1>,
-         get_argument<Caller, 2>,
-         get_argument<Caller, 3>,
-         get_argument<Caller, 4>,
-         get_result_type<Caller>
-> makeCallback4( const Caller& caller, get_argument<Caller, 0> callee ){
-	return Callback4<
-	            get_argument<Caller, 1>,
-	            get_argument<Caller, 2>,
-	            get_argument<Caller, 3>,
-	            get_argument<Caller, 4>,
-	            get_result_type<Caller>
-	       >( BindFirstOpaque<Caller>( callee ) );
-}
-template<typename Caller>
-inline Callback4<
-         get_argument<Caller, 0>,
-         get_argument<Caller, 1>,
-         get_argument<Caller, 2>,
-         get_argument<Caller, 3>,
-         get_result_type<Caller>
-> makeStatelessCallback4( const Caller& caller ){
-	return makeCallback4( Caller4To5<Caller>(), 0 );
-}
-
+template<class Object, class F>
+using ConstMemberFunction = typename detail::MemberFunction<Object, F>::type_const;
 
 /// \brief Forms a Callback from a non-const Environment reference and a non-const Environment member-function.
 ///
 /// \dontinclude generic/callback.cpp
 /// \skipline MemberCaller example
 /// \until end example
-template<class Environment, void(Environment::*member)()>
-using MemberCaller = BindFirstOpaque<Member<Environment, void, member>>;
+
+template<class Environment, class F, MemberFunction<Environment, F> member>
+using MemberCallerN = BindFirstOpaque<typename MemberN<Environment, F>::template instance<member>>;
 
 /// \brief Forms a Callback from a const Environment reference and a const Environment member-function.
 ///
 /// \dontinclude generic/callback.cpp
 /// \skipline MemberCaller example
 /// \until end example
-template<class Environment, void(Environment::*member)() const>
-using ConstMemberCaller = BindFirstOpaque<ConstMember<Environment, void, member>>;
-
-/// \brief Forms a Callback from a non-const Environment reference and a const Environment member-function which takes one argument.
-template<class Environment, class FirstArgument, void(Environment::*member)(FirstArgument)>
-using MemberCaller1 = BindFirstOpaque<Member1<Environment, FirstArgument, void, member>>;
-
-/// \brief Forms a Callback from a const Environment reference and a const Environment member-function which takes one argument.
-template<class Environment, class FirstArgument, void(Environment::*member)(FirstArgument) const>
-using ConstMemberCaller1 = BindFirstOpaque<ConstMember1<Environment, FirstArgument, void, member>>;
+template<class Environment, class F, ConstMemberFunction<Environment, F> member>
+using ConstMemberCallerN = BindFirstOpaque<typename ConstMemberN<Environment, F>::template instance<member>>;
 
 /// \brief Forms a Callback from a non-const Environment reference and a free function which operates on a non-const Environment reference.
 ///
 /// \dontinclude generic/callback.cpp
 /// \skipline ReferenceCaller example
 /// \until end example
-template<class Environment, void(*func)(Environment &)>
-using ReferenceCaller = BindFirstOpaque<Function1<Environment &, void, func>>;
+template<class Environment, class F, typename detail::Arglist<F>::template unshift<Environment &>::type *func>
+using ReferenceCallerN = BindFirstOpaque<typename FunctionN<typename detail::Arglist<F>::template unshift<Environment &>::type>::template instance<func>>;
 
 /// \brief Forms a Callback from a const Environment reference and a free function which operates on a const Environment reference.
 ///
 /// \dontinclude generic/callback.cpp
 /// \skipline ReferenceCaller example
 /// \until end example
-template<class Environment, void(*func)(const Environment &)>
-using ConstReferenceCaller = BindFirstOpaque<Function1<const Environment &, void, func>>;
-
-/// \brief Forms a Callback from a non-const Environment reference and a free function which operates on a non-const Environment reference and one other argument.
-template<class Environment, class FirstArgument, void(*func)(Environment &, FirstArgument)>
-using ReferenceCaller1 = BindFirstOpaque<Function2<Environment &, FirstArgument, void, func>>;
-
-/// \brief Forms a Callback from a const Environment reference and a free function which operates on a const Environment reference and one other argument.
-template<class Environment, class FirstArgument, void(*func)(const Environment &, FirstArgument)>
-using ConstReferenceCaller1 = BindFirstOpaque<Function2<const Environment &, FirstArgument, void, func>>;
+template<class Environment, class F, typename detail::Arglist<F>::template unshift<const Environment &>::type *func>
+using ConstReferenceCallerN = BindFirstOpaque<typename FunctionN<typename detail::Arglist<F>::template unshift<const Environment &>::type>::template instance<func>>;
 
 /// \brief Forms a Callback from a non-const Environment pointer and a free function which operates on a non-const Environment pointer.
-template<class Environment, void(*func)(Environment *)>
-using PointerCaller = BindFirstOpaque<Function1<Environment *, void, func>>;
+template<class Environment, class F, typename detail::Arglist<F>::template unshift<Environment *>::type *func>
+using PointerCallerN = BindFirstOpaque<typename FunctionN<typename detail::Arglist<F>::template unshift<Environment *>::type>::template instance<func>>;
 
 /// \brief Forms a Callback from a const Environment pointer and a free function which operates on a const Environment pointer.
-template<class Environment, void(*func)(const Environment *)>
-using ConstPointerCaller = BindFirstOpaque<Function1<const Environment *, void, func>>;
+template<class Environment, class F, typename detail::Arglist<F>::template unshift<const Environment *>::type *func>
+using ConstPointerCallerN = BindFirstOpaque<typename FunctionN<typename detail::Arglist<F>::template unshift<const Environment *>::type>::template instance<func>>;
 
-/// \brief Forms a Callback from a non-const Environment pointer and a free function which operates on a non-const Environment pointer and one other argument.
-template<class Environment, class FirstArgument, void(*func)(Environment *, FirstArgument)>
-using PointerCaller1 = BindFirstOpaque<Function2<Environment *, FirstArgument, void, func>>;
-
-/// \brief Forms a Callback from a const Environment pointer and a free function which operates on a const Environment pointer and one other argument.
-template<class Environment, class FirstArgument, void(*func)(const Environment *, FirstArgument)>
-using ConstPointerCaller1 = BindFirstOpaque<Function2<const Environment *, FirstArgument, void, func>>;
-
-/// \brief Forms a Callback from a free function which takes no arguments.
-template<void(*func)()>
-class FreeCaller : public BindFirstOpaque<Caller0To1<Function0<void, func>>>
-{
+/// \brief Forms a Callback from a free function
+template<class F, F *func>
+class FreeCallerN : public BindFirstOpaque<CallerShiftFirst<
+        typename FunctionN<F>::template instance<func>,
+        typename detail::Arglist<F>::template unshift<void *>::type
+>> {
 public:
-	FreeCaller() : BindFirstOpaque<Caller0To1<Function0<void, func>>>( 0 ){
+	FreeCallerN()
+	        : BindFirstOpaque<CallerShiftFirst<
+	        typename FunctionN<F>::template instance<func>,
+	        typename detail::Arglist<F>::template unshift<void *>::type
+	>>( nullptr ) {
 	}
 };
 
-/// \brief Forms a Callback from a free function which takes a single argument.
-template<class FirstArgument, void(*func)(FirstArgument)>
-class FreeCaller1 : public BindFirstOpaque<Caller1To2<Function1<FirstArgument, void, func>>>
-{
-public:
-	FreeCaller1() : BindFirstOpaque<Caller1To2<Function1<FirstArgument, void, func>>>( 0 ){
-	}
-};
-
-
-/// \brief Constructs a Callback from a non-const \p functor with zero arguments.
-///
-/// \param Functor Must define \c operator()().
-template<typename Functor>
-inline Callback makeCallback( Functor& functor ){
-	return Callback( MemberCaller<Functor, &Functor::operator()>( functor ) );
-}
-
-/// \brief  Constructs a Callback from a const \p functor with zero arguments.
-///
-/// \param Functor Must define const \c operator()().
-template<typename Functor>
-inline Callback makeCallback( const Functor& functor ){
-	return Callback( ConstMemberCaller<Functor, &Functor::operator()>( functor ) );
-}
-
-/// \brief  Constructs a Callback1 from a non-const \p functor with one argument.
+/// \brief  Constructs a Callback1 from a non-const \p functor
 ///
 /// \param Functor Must define \c operator()(argument) and its signature as \c func.
 template<typename Functor>
-inline Callback1<get_argument<Functor, 0>> makeCallback1( Functor& functor ){
-	typedef get_argument<Functor, 0> FirstArgument;
-	return Callback1<FirstArgument>( MemberCaller1<Functor, FirstArgument, &Functor::operator()>( functor ) );
+inline CallbackN<get_func<Functor>> makeCallbackN( Functor& functor ){
+	return CallbackN<get_func<Functor>>( MemberCallerN<Functor, get_func<Functor>, &Functor::operator()>( functor ) );
 }
 
-/// \brief  Constructs a Callback1 from a const \p functor with one argument.
+/// \brief  Constructs a Callback1 from a const \p functor
 ///
 /// \param Functor Must define const \c operator()(argument) and its signature as \c func.
 template<typename Functor>
-inline Callback1<get_argument<Functor, 0>> makeCallback1( const Functor& functor ){
-	typedef get_argument<Functor, 0> FirstArgument;
-	return Callback1<FirstArgument>( ConstMemberCaller1<Functor, FirstArgument, &Functor::operator()>( functor ) );
+inline CallbackN<get_func<Functor>> makeCallbackN( const Functor& functor ){
+	return CallbackN<get_func<Functor>>( ConstMemberCallerN<Functor, get_func<Functor>, &Functor::operator()>( functor ) );
 }
 
+// todo: inline
+
+#define makeCallback makeCallbackN
+
+using Callback = CallbackN<void()>;
+
+template<class Result>
+using Callback0 = CallbackN<Result()>;
+
+template<class FirstArgument, class Result = void>
+using Callback1 = CallbackN<Result(FirstArgument)>;
+
+template<typename FirstArgument, typename SecondArgument, typename Result = void>
+using Callback2 = CallbackN<Result(FirstArgument, SecondArgument)>;
+
+template<typename FirstArgument, typename SecondArgument, typename ThirdArgument, typename Result = void>
+using Callback3 = CallbackN<Result(FirstArgument, SecondArgument, ThirdArgument)>;
+
+template<typename FirstArgument, typename SecondArgument, typename ThirdArgument, typename FourthArgument, typename Result = void>
+using Callback4 = CallbackN<Result(FirstArgument, SecondArgument, ThirdArgument, FourthArgument)>;
+
+#define makeCallback0 makeCallbackN
+#define makeStatelessCallback0 makeStatelessCallbackN
+
+#define makeCallback1 makeCallbackN
+#define makeStatelessCallback1 makeStatelessCallbackN
+
+#define makeCallback2 makeCallbackN
+#define makeStatelessCallback2 makeStatelessCallbackN
+
+#define makeCallback3 makeCallbackN
+#define makeStatelessCallback3 makeStatelessCallbackN
+
+#define makeCallback4 makeCallbackN
+#define makeStatelessCallback4 makeStatelessCallbackN
+
+template<class Environment, void(Environment::*member)()>
+using MemberCaller = MemberCallerN<Environment, void(), member>;
+
+template<class Environment, void(Environment::*member)() const>
+using ConstMemberCaller = ConstMemberCallerN<Environment, void(), member>;
+
+template<class Environment, class FirstArgument, void(Environment::*member)(FirstArgument)>
+using MemberCaller1 = MemberCallerN<Environment, void(FirstArgument), member>;
+
+template<class Environment, class FirstArgument, void(Environment::*member)(FirstArgument) const>
+using ConstMemberCaller1 = ConstMemberCallerN<Environment, void(FirstArgument), member>;
+
+template<class Environment, void(*func)(Environment &)>
+using ReferenceCaller = ReferenceCallerN<Environment, void(), func>;
+
+template<class Environment, void(*func)(const Environment &)>
+using ConstReferenceCaller = ConstReferenceCallerN<Environment, void(), func>;
+
+/// \brief Forms a Callback from a non-const Environment reference and a free function which operates on a non-const Environment reference and one other argument.
+template<class Environment, class FirstArgument, void(*func)(Environment &, FirstArgument)>
+using ReferenceCaller1 = ReferenceCallerN<Environment, void(FirstArgument), func>;
+
+/// \brief Forms a Callback from a const Environment reference and a free function which operates on a const Environment reference and one other argument.
+template<class Environment, class FirstArgument, void(*func)(const Environment &, FirstArgument)>
+using ConstReferenceCaller1 = ConstReferenceCallerN<Environment, void(FirstArgument), func>;
+
+/// \brief Forms a Callback from a non-const Environment pointer and a free function which operates on a non-const Environment pointer.
+template<class Environment, void(*func)(Environment *)>
+using PointerCaller = PointerCallerN<Environment, void(), func>;
+
+/// \brief Forms a Callback from a const Environment pointer and a free function which operates on a const Environment pointer.
+template<class Environment, void(*func)(const Environment *)>
+using ConstPointerCaller = ConstPointerCallerN<Environment, void(), func>;
+
+/// \brief Forms a Callback from a non-const Environment pointer and a free function which operates on a non-const Environment pointer and one other argument.
+template<class Environment, class FirstArgument, void(*func)(Environment *, FirstArgument)>
+using PointerCaller1 = PointerCallerN<Environment, void(FirstArgument), func>;
+
+/// \brief Forms a Callback from a const Environment pointer and a free function which operates on a const Environment pointer and one other argument.
+template<class Environment, class FirstArgument, void(*func)(const Environment *, FirstArgument)>
+using ConstPointerCaller1 = ConstPointerCallerN<Environment, void(FirstArgument), func>;
+
+template<void(*func)()>
+using FreeCaller = FreeCallerN<void(), func>;
+
+template<class FirstArgument, void(*func)(FirstArgument)>
+using FreeCaller1 = FreeCallerN<void(FirstArgument), func>;
 
 typedef Callback1<bool> BoolImportCallback;
 typedef Callback1<const BoolImportCallback&> BoolExportCallback;
diff --git a/libs/generic/callbackfwd.h b/libs/generic/callbackfwd.h
deleted file mode 100644
index 89ddb2d4..00000000
--- a/libs/generic/callbackfwd.h
+++ /dev/null
@@ -1,15 +0,0 @@
-
-#pragma once
-
-template<typename Return>
-class Callback0;
-typedef Callback0<void> Callback;
-
-template<typename FirstArgument, typename Result = void>
-class Callback1;
-
-template<typename FirstArgument, typename SecondArgument, typename Result = void>
-class Callback2;
-
-template<typename FirstArgument, typename SecondArgument, typename ThirdArgument, typename Result = void>
-class Callback3;
diff --git a/libs/generic/functional.h b/libs/generic/functional.h
index c0252360..50ccdad1 100644
--- a/libs/generic/functional.h
+++ b/libs/generic/functional.h
@@ -197,6 +197,8 @@ public:
 template<class Functor>
 using FunctorInvoke = FunctorNInvoke<Functor, get_func<Functor>>;
 
+// todo: inline
+
 template<class Object, class R, R(Object::*member)()>
 using Member = typename MemberN<Object, R()>::template instance<member>;
 
@@ -238,38 +240,3 @@ using Function4 = typename FunctionN<R(A1, A2, A3, A4)>::template instance<func>
 
 template<class A1, class A2, class A3, class A4, class A5, class R, R(*func)(A1, A2, A3, A4, A5)>
 using Function5 = typename FunctionN<R(A1, A2, A3, A4, A5)>::template instance<func>;
-
-template<class Caller, class FirstArgument = void *>
-using Caller0To1 = CallerShiftFirst<Caller, get_result_type<Caller>(
-        FirstArgument
-)>;
-
-template<class Caller, class FirstArgument = void *>
-using Caller1To2 = CallerShiftFirst<Caller, get_result_type<Caller>(
-        FirstArgument,
-        get_argument<Caller, 0>
-)>;
-
-template<class Caller, class FirstArgument = void *>
-using Caller2To3 = CallerShiftFirst<Caller, get_result_type<Caller>(
-        FirstArgument,
-        get_argument<Caller, 0>,
-        get_argument<Caller, 1>
-)>;
-
-template<class Caller, class FirstArgument = void *>
-using Caller3To4 = CallerShiftFirst<Caller, get_result_type<Caller>(
-        FirstArgument,
-        get_argument<Caller, 0>,
-        get_argument<Caller, 1>,
-        get_argument<Caller, 2>
-)>;
-
-template<class Caller, class FirstArgument = void *>
-using Caller4To5 = CallerShiftFirst<Caller, get_result_type<Caller>(
-        FirstArgument,
-        get_argument<Caller, 0>,
-        get_argument<Caller, 1>,
-        get_argument<Caller, 2>,
-        get_argument<Caller, 3>
-)>;
diff --git a/libs/gtkutil/menu.h b/libs/gtkutil/menu.h
index 69635cfb..936bc29e 100644
--- a/libs/gtkutil/menu.h
+++ b/libs/gtkutil/menu.h
@@ -21,7 +21,7 @@
 
 #pragma once
 
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 #include <QMenu>
 
diff --git a/libs/gtkutil/toolbar.h b/libs/gtkutil/toolbar.h
index d2341b40..ca88e943 100644
--- a/libs/gtkutil/toolbar.h
+++ b/libs/gtkutil/toolbar.h
@@ -21,7 +21,7 @@
 
 #pragma once
 
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 #include <QToolBar>
 
 QAction* toolbar_append_button( QToolBar* toolbar, const char* description, const char* icon, const Callback& callback );
diff --git a/radiant/brushmanip.h b/radiant/brushmanip.h
index 222ed58e..3c18ea1b 100644
--- a/radiant/brushmanip.h
+++ b/radiant/brushmanip.h
@@ -23,7 +23,7 @@
 
 #include <cstddef>
 #include "string/stringfwd.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 enum class EBrushPrefab
 {
diff --git a/radiant/selection.h b/radiant/selection.h
index 1b37316f..29741084 100644
--- a/radiant/selection.h
+++ b/radiant/selection.h
@@ -22,7 +22,7 @@
 #pragma once
 
 #include "windowobserver.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 #include "rect_t.h"
 
 typedef Callback1<rect_t> RectangleCallback;
diff --git a/radiant/textures.h b/radiant/textures.h
index f9b64860..6bbff126 100644
--- a/radiant/textures.h
+++ b/radiant/textures.h
@@ -21,7 +21,7 @@
 
 #pragma once
 
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 void Textures_Realise();
 void Textures_Unrealise();
diff --git a/radiant/texwindow.h b/radiant/texwindow.h
index f02aea71..7ac72d51 100644
--- a/radiant/texwindow.h
+++ b/radiant/texwindow.h
@@ -21,7 +21,7 @@
 
 #pragma once
 
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 #include "signal/signalfwd.h"
 
 class QWidget;
@@ -36,8 +36,6 @@ void TextureBrowser_Destroy();
 
 
 typedef Callback1<const char*> StringImportCallback;
-template<typename FirstArgument, void( *func ) (FirstArgument)>
-class FreeCaller1;
 
 extern QWidget* g_page_textures;
 void TextureBrowser_exportTitle( const StringImportCallback& importer );