Merge pull request #1920 from elfprince13/variadicConsoleTemplates

Variadic console templates

Engine/source/T3D/aiPlayer.cpp

@@ -1317,7 +1317,7 @@ bool AIPlayer::checkInLos(GameBase* target, bool _useMuzzle, bool _checkEnabled)
    return hit;
 }
 
-DefineEngineMethod(AIPlayer, checkInLos, bool, (ShapeBase* obj,  bool useMuzzle, bool checkEnabled),(NULL, false, false),
+DefineEngineMethod(AIPlayer, checkInLos, bool, (ShapeBase* obj,  bool useMuzzle, bool checkEnabled),(nullAsType<ShapeBase*>(), false, false),
    "@brief Check whether an object is in line of sight.\n"
    "@obj Object to check. (If blank, it will check the current target).\n"
    "@useMuzzle Use muzzle position. Otherwise use eye position. (defaults to false).\n"
@@ -1366,7 +1366,7 @@ bool AIPlayer::checkInFoV(GameBase* target, F32 camFov, bool _checkEnabled)
    return (dot > mCos(camFov));
 }
 
-DefineEngineMethod(AIPlayer, checkInFoV, bool, (ShapeBase* obj, F32 fov, bool checkEnabled), (NULL, 45.0f, false),
+DefineEngineMethod(AIPlayer, checkInFoV, bool, (ShapeBase* obj, F32 fov, bool checkEnabled), (nullAsType<ShapeBase*>(), 45.0f, false),
    "@brief Check whether an object is within a specified veiw cone.\n"
    "@obj Object to check. (If blank, it will check the current target).\n"
    "@fov view angle in degrees.(Defaults to 45)\n"
@@ -1440,7 +1440,7 @@ F32 AIPlayer::getTargetDistance(GameBase* target, bool _checkEnabled)
    return (getPosition() - target->getPosition()).len();
 }
 
-DefineEngineMethod(AIPlayer, getTargetDistance, F32, (ShapeBase* obj, bool checkEnabled), (NULL, false),
+DefineEngineMethod(AIPlayer, getTargetDistance, F32, (ShapeBase* obj, bool checkEnabled), (nullAsType<ShapeBase*>(), false),
    "@brief The distance to a given object.\n"
    "@obj Object to check. (If blank, it will check the current target).\n"
    "@checkEnabled check whether the object can take damage and if so is still alive.(Defaults to false)\n")

Engine/source/T3D/fx/particleEmitterNode.cpp

@@ -395,7 +395,7 @@ void ParticleEmitterNode::setEmitterDataBlock(ParticleEmitterData* data)
 }
 
 
-DefineEngineMethod(ParticleEmitterNode, setEmitterDataBlock, void, (ParticleEmitterData* emitterDatablock), (NULL),
+DefineEngineMethod(ParticleEmitterNode, setEmitterDataBlock, void, (ParticleEmitterData* emitterDatablock), (nullAsType<ParticleEmitterData*>()),
    "Assigns the datablock for this emitter node.\n"
    "@param emitterDatablock ParticleEmitterData datablock to assign\n"
    "@tsexample\n"

Engine/source/T3D/fx/ribbonNode.cpp

@@ -39,7 +39,6 @@ ConsoleDocClass( RibbonNodeData,
 ConsoleDocClass( RibbonNode, ""
    );
 
-
 //-----------------------------------------------------------------------------
 // RibbonNodeData
 //-----------------------------------------------------------------------------
@@ -299,7 +298,7 @@ void RibbonNode::setRibbonDatablock(RibbonData* data)
    mRibbonDatablock = data;
 }
 
-DefineEngineMethod(RibbonNode, setRibbonDatablock, void, (RibbonData* ribbonDatablock), (0),
+DefineEngineMethod(RibbonNode, setRibbonDatablock, void, (RibbonData* ribbonDatablock), (nullAsType<RibbonData*>()),
    "Assigns the datablock for this ribbon node.\n"
    "@param ribbonDatablock RibbonData datablock to assign\n"
    "@tsexample\n"

Engine/source/T3D/tsStatic.cpp

@@ -1256,7 +1256,7 @@ DefineEngineMethod( TSStatic, getTargetCount, S32,(),,
 // This method is able to change materials per map to with others. The material that is being replaced is being mapped to
 // unmapped_mat as a part of this transition
 
-DefineEngineMethod( TSStatic, changeMaterial, void, ( const char* mapTo, Material* oldMat, Material* newMat ),("",NULL,NULL),
+DefineEngineMethod( TSStatic, changeMaterial, void, ( const char* mapTo, Material* oldMat, Material* newMat ),("",nullAsType<Material*>(),nullAsType<Material*>()),
    "@brief Change one of the materials on the shape.\n\n"
 
    "This method changes materials per mapTo with others. The material that "
@@ -1323,4 +1323,4 @@ DefineEngineMethod( TSStatic, getModelFile, const char *, (),,
    )
 {
 	return object->getShapeFileName();
-}
+}

Engine/source/app/badWordFilter.cpp

@@ -254,7 +254,7 @@ DefineEngineFunction(addBadWord, bool, (const char* badWord),,
 	return gBadWordFilter->addBadWord(badWord);
 }
 
-DefineEngineFunction(filterString, const char *, (const char* baseString, const char* replacementChars), (NULL, NULL),
+DefineEngineFunction(filterString, const char *, (const char* baseString, const char* replacementChars), (nullAsType<const char*>(), nullAsType<const char*>()),
    "@brief Replaces the characters in a string with designated text\n\n"
 
    "Uses the bad word filter to determine which characters within the string will be replaced.\n\n"

Engine/source/console/console.h

@@ -95,8 +95,8 @@ struct ConsoleLogEntry
       Script,
       GUI,
       Network,
-	  GGConnect,
-	  NUM_TYPE
+     GGConnect,
+     NUM_TYPE
    } mType;
 
    /// Indicates the actual log entry.
@@ -897,34 +897,28 @@ template<typename P1> struct _EngineConsoleExecCallbackHelper;
 
 namespace Con
 {
-	/// @name Console Execution - executef
-	/// {
-	///
-	/// Implements a script function thunk which automatically converts parameters to relevant console types.
-	/// Can be used as follows:
-	/// - Con::executef("functionName", ...);
-	/// - Con::executef(mySimObject, "functionName", ...);
-	/// 
-	/// NOTE: if you get a rather cryptic template error coming through here, most likely you are trying to 
-	/// convert a parameter which EngineMarshallType does not have a specialization for.
-	/// Another problem can occur if you do not include "console/simBase.h" and "console/engineAPI.h" 
-	/// since _EngineConsoleExecCallbackHelper and SimConsoleThreadExecCallback are required.
-	///
-	/// @see _EngineConsoleExecCallbackHelper
-	///
-	template<typename A> ConsoleValueRef executef(A a) { _EngineConsoleExecCallbackHelper<A> callback( a ); return callback.template call<ConsoleValueRef>(); }
-	template<typename A, typename B> ConsoleValueRef executef(A a, B b) { _EngineConsoleExecCallbackHelper<A> callback( a ); return callback.template call<ConsoleValueRef>(b); }
-	template<typename A, typename B, typename C> ConsoleValueRef executef(A a, B b, C c) { _EngineConsoleExecCallbackHelper<A> callback( a ); return callback.template call<ConsoleValueRef>(b, c); }
-	template<typename A, typename B, typename C, typename D> ConsoleValueRef executef(A a, B b, C c, D d) { _EngineConsoleExecCallbackHelper<A> callback( a ); return callback.template call<ConsoleValueRef>(b, c, d); }
-	template<typename A, typename B, typename C, typename D, typename E> ConsoleValueRef executef(A a, B b, C c, D d, E e) { _EngineConsoleExecCallbackHelper<A> callback( a ); return callback.template call<ConsoleValueRef>(b, c, d, e); }
-	template<typename A, typename B, typename C, typename D, typename E, typename F> ConsoleValueRef executef(A a, B b, C c, D d, E e, F f) { _EngineConsoleExecCallbackHelper<A> callback( a ); return callback.template call<ConsoleValueRef>(b, c, d, e, f); }
-	template<typename A, typename B, typename C, typename D, typename E, typename F, typename G> ConsoleValueRef executef(A a, B b, C c, D d, E e, F f, G g) { _EngineConsoleExecCallbackHelper<A> callback( a ); return callback.template call<ConsoleValueRef>(b, c, d, e, f, g); }
-	template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H> ConsoleValueRef executef(A a, B b, C c, D d, E e, F f, G g, H h) { _EngineConsoleExecCallbackHelper<A> callback( a ); return callback.template call<ConsoleValueRef>(b, c, d, e, f, g, h); }
-	template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I> ConsoleValueRef executef(A a, B b, C c, D d, E e, F f, G g, H h, I i) { _EngineConsoleExecCallbackHelper<A> callback( a ); return callback.template call<ConsoleValueRef>(b, c, d, e, f, g, h, i); }
-	template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J> ConsoleValueRef executef(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j) { _EngineConsoleExecCallbackHelper<A> callback( a ); return callback.template call<ConsoleValueRef>(b, c, d, e, f, g, h, i, j); }
-	template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K> ConsoleValueRef executef(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k) { _EngineConsoleExecCallbackHelper<A> callback( a ); return callback.template call<ConsoleValueRef>(b, c, d, e, f, g, h, i, j, k); }
-	template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L> ConsoleValueRef executef(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l) { _EngineConsoleExecCallbackHelper<A> callback( a ); return callback.template call<ConsoleValueRef>(b, c, d, e, f, g, h, i, j, k, l); }
-	/// }
+   /// @name Console Execution - executef
+   /// {
+   ///
+   /// Implements a script function thunk which automatically converts parameters to relevant console types.
+   /// Can be used as follows:
+   /// - Con::executef("functionName", ...);
+   /// - Con::executef(mySimObject, "functionName", ...);
+   /// 
+   /// NOTE: if you get a rather cryptic template error coming through here, most likely you are trying to 
+   /// convert a parameter which EngineMarshallType does not have a specialization for.
+   /// Another problem can occur if you do not include "console/simBase.h" and "console/engineAPI.h" 
+   /// since _EngineConsoleExecCallbackHelper and SimConsoleThreadExecCallback are required.
+   ///
+   /// @see _EngineConsoleExecCallbackHelper
+   ///
+   template<typename R, typename ...ArgTs>
+   ConsoleValueRef executef(R r, ArgTs ...argTs)
+   {
+      _EngineConsoleExecCallbackHelper<R> callback( r );
+      return callback.template call<ConsoleValueRef>(argTs...);
+   }
+   /// }
 };
 
 extern void expandEscape(char *dest, const char *src);
@@ -1149,19 +1143,19 @@ class ConsoleStackFrameSaver
 {
 public:
 
-	bool mSaved;
+   bool mSaved;
 
-	ConsoleStackFrameSaver() : mSaved(false)
-	{
-	}
+   ConsoleStackFrameSaver() : mSaved(false)
+   {
+   }
 
-	~ConsoleStackFrameSaver()
-	{
-		restore();
-	}
+   ~ConsoleStackFrameSaver()
+   {
+      restore();
+   }
 
-	void save();
-	void restore();
+   void save();
+   void restore();
 };
 
 

Engine/source/console/consoleTypes.h

@@ -39,6 +39,7 @@
 #include "console/engineStructs.h"
 #endif
 
+template<typename T> inline const T nullAsType(){ return nullptr; }
 
 /// @file
 /// Legacy TS-based console type definitions.

Engine/source/console/engineAPI.h

@@ -23,6 +23,9 @@
 #ifndef _ENGINEAPI_H_
 #define _ENGINEAPI_H_
 
+#include <tuple>
+#include <utility>
+
 #ifndef _CONSOLETYPES_H_
 #include "console/consoleTypes.h"
 #endif
@@ -333,4322 +336,979 @@ struct EngineUnmarshallData< ConsoleValueRef >
 /// @{
 
 // Helper type to factor out commonalities between function and method trampolines.
-template< typename T >
-struct _EngineTrampoline
-{
+
+
+template<typename T> struct _EngineTrampoline {
    struct Args {};
 };
 
-template< typename R, typename A >
-struct _EngineTrampoline< R( A ) >
+template< typename R, typename ...ArgTs >
+struct _EngineTrampoline< R( ArgTs ... ) >
 {
-   struct Args
-   {
-      char data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) ];
-
-      typename EngineTypeTraits< A >::ValueType a() const
-      {
-         return EngineTypeTraits< A >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< A >::ArgumentValueType* >
-               ( &data[ 0 ] ) ) );
-      }
-   };
+   typedef std::tuple<ArgTs ...> Args;
+   std::tuple<ArgTs ...> argT;
 };
 
-template< typename R, typename A, typename B >
-struct _EngineTrampoline< R( A, B ) >
+template< typename T >
+struct _EngineFunctionTrampolineBase : public _EngineTrampoline< T >
 {
-   struct Args
-   {
-      char data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) ];
-
-      typename EngineTypeTraits< A >::ValueType a() const
-      {
-         return EngineTypeTraits< A >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< A >::ArgumentValueType* >
-               ( &data[ 0 ] ) ) );
-      }
-
-      typename EngineTypeTraits< B >::ValueType b() const
-      {
-         return EngineTypeTraits< B >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< B >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) ] ) ) );
-      }
-   };
+   typedef T FunctionType;
 };
 
-template< typename R, typename A, typename B, typename C >
-struct _EngineTrampoline< R( A, B, C ) >
+// Trampolines for any call-ins that aren't methods.
+template< typename T >
+struct _EngineFunctionTrampoline {};
+
+template< typename R, typename ...ArgTs >
+struct _EngineFunctionTrampoline< R(ArgTs...) > : public _EngineFunctionTrampolineBase< R(ArgTs...) >
 {
-   struct Args
+private:
+   using Super = _EngineFunctionTrampolineBase< R(ArgTs...) >;
+   using ArgsType = typename Super::Args;
+   
+   template<size_t ...> struct Seq {};
+   template<size_t N, size_t ...S> struct Gens : Gens<N-1, N-1, S...> {};
+   template<size_t ...I> struct Gens<0, I...>{ typedef Seq<I...> type; };
+   
+   template<size_t ...I>
+   static R dispatchHelper(typename Super::FunctionType fn, const ArgsType& args, Seq<I...>)  {
+      return R( fn(std::get<I>(args) ...) );
+   }
+
+   using SeqType = typename Gens<sizeof...(ArgTs)>::type;
+public:
+   static R jmp(typename Super::FunctionType fn, const ArgsType& args )
    {
-      char data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) ];
+      return dispatchHelper(fn, args, SeqType());
+   }
+};
 
-      typename EngineTypeTraits< A >::ValueType a() const
-      {
-         return EngineTypeTraits< A >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< A >::ArgumentValueType* >
-               ( &data[ 0 ] ) ) );
-      }
+// Trampolines for engine methods
 
-      typename EngineTypeTraits< B >::ValueType b() const
-      {
-         return EngineTypeTraits< B >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< B >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) ] ) ) );
-      }
+template< typename T >
+struct _EngineMethodTrampolineBase : public _EngineTrampoline< T > {};
 
-      typename EngineTypeTraits< C >::ValueType c() const
-      {
-         return EngineTypeTraits< C >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< C >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) ] ) ) );
-      }
-   };
-};
+template< typename Frame, typename T >
+struct _EngineMethodTrampoline {};
 
-template< typename R, typename A, typename B, typename C, typename D >
-struct _EngineTrampoline< R( A, B, C, D ) >
+template< typename Frame, typename R, typename ...ArgTs >
+struct _EngineMethodTrampoline< Frame, R(ArgTs ...) > : public _EngineMethodTrampolineBase< R(ArgTs ...) >
 {
-   struct Args
+   using FunctionType = R( typename Frame::ObjectType*, ArgTs ...);
+private:
+   using Super = _EngineMethodTrampolineBase< R(ArgTs ...) >;
+   using ArgsType = typename _EngineFunctionTrampolineBase< R(ArgTs ...) >::Args;
+   
+   template<size_t ...> struct Seq {};
+   template<size_t N, size_t ...S> struct Gens : Gens<N-1, N-1, S...> {};
+   template<size_t ...I> struct Gens<0, I...>{ typedef Seq<I...> type; };
+   
+   template<size_t ...I>
+   static R dispatchHelper(Frame f, const ArgsType& args, Seq<I...>)  {
+      return R( f._exec(std::get<I>(args) ...) );
+   }
+   
+   using SeqType = typename Gens<sizeof...(ArgTs)>::type;
+public:
+   static R jmp( typename Frame::ObjectType* object, const ArgsType& args )
    {
-      char data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) ];
+      
+      Frame f;
+      f.object = object;
+      return dispatchHelper(f, args, SeqType());
+   }
+};
 
-      typename EngineTypeTraits< A >::ValueType a() const
-      {
-         return EngineTypeTraits< A >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< A >::ArgumentValueType* >
-               ( &data[ 0 ] ) ) );
-      }
+/// @}
 
-      typename EngineTypeTraits< B >::ValueType b() const
-      {
-         return EngineTypeTraits< B >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< B >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) ] ) ) );
-      }
 
-      typename EngineTypeTraits< C >::ValueType c() const
-      {
-         return EngineTypeTraits< C >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< C >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) ] ) ) );
-      }
+/// @name Thunking
+///
+/// Internal functionality for thunks placed between TorqueScript calls of engine functions and their native
+/// implementations.
+///
+/// @note The functionality in this group is specific to the console interop system.
+/// @{
 
-      typename EngineTypeTraits< D >::ValueType d() const
-      {
-         return EngineTypeTraits< D >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< D >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) ] ) ) );
-      }
-   };
-};
 
-template< typename R, typename A, typename B, typename C, typename D, typename E >
-struct _EngineTrampoline< R( A, B, C, D, E ) >
+// Helper function to return data from a thunk.
+template< typename T >
+inline const char* _EngineConsoleThunkReturnValue( const T& value )
 {
-   struct Args
-   {
-      char data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) ];
-
-      typename EngineTypeTraits< A >::ValueType a() const
-      {
-         return EngineTypeTraits< A >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< A >::ArgumentValueType* >
-               ( &data[ 0 ] ) ) );
-      }
+   return EngineMarshallData( value );
+}
 
-      typename EngineTypeTraits< B >::ValueType b() const
-      {
-         return EngineTypeTraits< B >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< B >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) ] ) ) );
-      }
+inline bool _EngineConsoleThunkReturnValue( bool value )
+{
+   return value;
+}
+inline S32 _EngineConsoleThunkReturnValue( S32 value )
+{
+   return value;
+}
+inline F32 _EngineConsoleThunkReturnValue( F32 value )
+{
+   return value;
+}
+inline const char* _EngineConsoleThunkReturnValue( const String& str )
+{
+   return Con::getReturnBuffer( str );
+}
+inline const char* _EngineConsoleThunkReturnValue( const char* value )
+{
+   return EngineMarshallData( value );
+}
+template< typename T >
+inline const char* _EngineConsoleThunkReturnValue( T* value )
+{
+   return ( value ? value->getIdString() : "" );
+}
+template< typename T >
+inline const char* _EngineConsoleThunkReturnValue( const T* value )
+{
+   return ( value ? value->getIdString() : "" );
+}
 
-      typename EngineTypeTraits< C >::ValueType c() const
-      {
-         return EngineTypeTraits< C >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< C >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) ] ) ) );
-      }
 
-      typename EngineTypeTraits< D >::ValueType d() const
-      {
-         return EngineTypeTraits< D >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< D >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) ] ) ) );
-      }
 
-      typename EngineTypeTraits< E >::ValueType e() const
-      {
-         return EngineTypeTraits< E >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< E >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) ] ) ) );
-      }
-   };
+// Helper class to determine the type of callback registered with the console system.
+template< typename R >
+struct _EngineConsoleThunkType
+{
+   typedef const char* ReturnType;
+   typedef StringCallback CallbackType;
 };
-
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F >
-struct _EngineTrampoline< R( A, B, C, D, E, F ) >
+template<>
+struct _EngineConsoleThunkType< S32 >
 {
-   struct Args
-   {
-      char data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) ];
-
-      typename EngineTypeTraits< A >::ValueType a() const
-      {
-         return EngineTypeTraits< A >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< A >::ArgumentValueType* >
-               ( &data[ 0 ] ) ) );
-      }
-
-      typename EngineTypeTraits< B >::ValueType b() const
-      {
-         return EngineTypeTraits< B >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< B >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< C >::ValueType c() const
-      {
-         return EngineTypeTraits< C >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< C >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) ] ) ) );
-      }
+   typedef S32 ReturnType;
+   typedef IntCallback CallbackType;
+};
+template<>
+struct _EngineConsoleThunkType< U32 >
+{
+   typedef U32 ReturnType;
+   typedef IntCallback CallbackType;
+};
+template<>
+struct _EngineConsoleThunkType< F32 >
+{
+   typedef F32 ReturnType;
+   typedef FloatCallback CallbackType;
+};
+template<>
+struct _EngineConsoleThunkType< bool >
+{
+   typedef bool ReturnType;
+   typedef BoolCallback CallbackType;
+};
+template<>
+struct _EngineConsoleThunkType< void >
+{
+   typedef void ReturnType;
+   typedef VoidCallback CallbackType;
+};
 
-      typename EngineTypeTraits< D >::ValueType d() const
-      {
-         return EngineTypeTraits< D >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< D >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) ] ) ) );
-      }
 
-      typename EngineTypeTraits< E >::ValueType e() const
-      {
-         return EngineTypeTraits< E >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< E >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) ] ) ) );
-      }
+// Helper struct to count the number of parameters in a function list.
+// The setup through operator () allows omitting the the argument list entirely.
+struct _EngineConsoleThunkCountArgs
+{
 
-      typename EngineTypeTraits< F >::ValueType f() const
-      {
-         return EngineTypeTraits< F >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< F >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) ] ) ) );
-      }
-   };
+   template<typename ...ArgTs> U32 operator()(ArgTs... args){
+      return sizeof...(ArgTs);
+   }
+   
+   operator U32() const{ // FIXME: WHAT IS THIS?? I'm pretty sure it's incorrect, and it's the version that is invoked by all the macros
+      return 0;
+   }
 };
 
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-struct _EngineTrampoline< R( A, B, C, D, E, F, G ) >
-{
-   struct Args
-   {
-      char data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) ];
-
-      typename EngineTypeTraits< A >::ValueType a() const
-      {
-         return EngineTypeTraits< A >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< A >::ArgumentValueType* >
-               ( &data[ 0 ] ) ) );
-      }
-
-      typename EngineTypeTraits< B >::ValueType b() const
-      {
-         return EngineTypeTraits< B >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< B >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) ] ) ) );
-      }
 
-      typename EngineTypeTraits< C >::ValueType c() const
-      {
-         return EngineTypeTraits< C >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< C >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) ] ) ) );
-      }
 
-      typename EngineTypeTraits< D >::ValueType d() const
-      {
-         return EngineTypeTraits< D >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< D >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) ] ) ) );
-      }
 
-      typename EngineTypeTraits< E >::ValueType e() const
-      {
-         return EngineTypeTraits< E >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< E >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) ] ) ) );
-      }
+// Encapsulation of a legacy console function invocation.
+namespace engineAPI{
+   namespace detail{
+      template<S32 startArgc, typename R, typename ...ArgTs>
+      struct ThunkHelpers {
+         using SelfType = ThunkHelpers<startArgc, R, ArgTs...>;
+         using FunctionType = R(*)(ArgTs...);
+         template<typename Frame> using MethodType = R(Frame::*)(ArgTs ...) const;
+         template<size_t I> using IthArgType = typename std::tuple_element<I, std::tuple<ArgTs ...> >::type;
+         
+         template<size_t ...> struct Seq {};
+         template<size_t N, size_t ...S> struct Gens : Gens<N-1, N-1, S...> {};
+         template<size_t ...I> struct Gens<0, I...>{ typedef Seq<I...> type; };
+         
+         typedef typename _EngineConsoleThunkType< R >::ReturnType ReturnType;
+         static const S32 NUM_ARGS = sizeof...(ArgTs) + startArgc;
+         
+         template<size_t index, size_t method_offset = 0, typename ...RealArgTs>
+         static IthArgType<index> getRealArgValue(S32 argc, ConsoleValueRef *argv, const _EngineFunctionDefaultArguments< void(RealArgTs...) >& defaultArgs)
+         {
+            if((startArgc + index) < argc)
+            {
+               return EngineUnmarshallData< IthArgType<index> >()( argv[ startArgc + index ] );
+            } else {
+               return std::get<index + method_offset>(defaultArgs.mArgs);
+            }
+         }
+         
+         template<size_t ...I>
+         static R dispatchHelper(S32 argc, ConsoleValueRef *argv, FunctionType fn, const _EngineFunctionDefaultArguments< void(ArgTs...) >& defaultArgs, Seq<I...>){
+            return fn(SelfType::getRealArgValue<I>(argc, argv, defaultArgs) ...);
+         }
+         
+         template<typename Frame, size_t ...I>
+         static R dispatchHelper(S32 argc, ConsoleValueRef *argv, MethodType<Frame> fn, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, ArgTs...) >& defaultArgs, Seq<I...>){
+            return (frame->*fn)(SelfType::getRealArgValue<I,1>(argc, argv, defaultArgs) ...);
+         }
+         
+         using SeqType = typename Gens<sizeof...(ArgTs)>::type;
+      };
+      
+      template<typename ArgVT> struct MarshallHelpers {
+         template<typename ...ArgTs> static void marshallEach(S32 &argc, ArgVT *argv, const ArgTs& ...args){}
+         template<typename H, typename ...Tail> static void marshallEach(S32 &argc, ArgVT *argv, const H& head, const Tail& ...tail){
+            argv[argc++] = EngineMarshallData(head);
+            marshallEach(argc, argv, tail...);
+         }
+      };
+      
+      template<> struct MarshallHelpers<ConsoleValueRef> {
+         template<typename ...ArgTs> static void marshallEach(S32 &argc, ConsoleValueRef *argv, const ArgTs& ...args){}
+         template<typename H, typename ...Tail> static void marshallEach(S32 &argc, ConsoleValueRef *argv, const H& head, const Tail& ...tail){
+            EngineMarshallData(head, argc, argv);
+            marshallEach(argc, argv, tail...);
+         }
+      };
+   }
+}
 
-      typename EngineTypeTraits< F >::ValueType f() const
-      {
-         return EngineTypeTraits< F >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< F >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) ] ) ) );
-      }
+template< S32 startArgc, typename T >
+struct _EngineConsoleThunk {};
 
-      typename EngineTypeTraits< G >::ValueType g() const
-      {
-         return EngineTypeTraits< G >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< G >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) ] ) ) );
-      }
-   };
+template< S32 startArgc, typename R, typename ...ArgTs >
+struct _EngineConsoleThunk< startArgc, R(ArgTs...) >
+{
+private:
+   using Helper = engineAPI::detail::ThunkHelpers<startArgc, R, ArgTs...>;
+   using SeqType = typename Helper::SeqType;
+public:
+   typedef typename Helper::FunctionType FunctionType;
+   typedef typename Helper::ReturnType ReturnType;
+   template<typename Frame> using MethodType = typename Helper::template MethodType<Frame>;
+   static const S32 NUM_ARGS = Helper::NUM_ARGS;
+   
+   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, FunctionType fn, const _EngineFunctionDefaultArguments< void(ArgTs...) >& defaultArgs)
+   {
+      return _EngineConsoleThunkReturnValue( Helper::dispatchHelper(argc, argv, fn, defaultArgs, SeqType()));
+   }
+   template< typename Frame >
+   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, MethodType<Frame> fn, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, ArgTs...) >& defaultArgs)
+   {
+      return _EngineConsoleThunkReturnValue( Helper::dispatchHelper(argc, argv, fn, frame, defaultArgs, SeqType()));
+   }
 };
 
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-struct _EngineTrampoline< R( A, B, C, D, E, F, G, H ) >
-{
-   struct Args
+// Have to do a partial specialization for void-returning functions :(
+template<S32 startArgc, typename ...ArgTs>
+struct _EngineConsoleThunk<startArgc, void(ArgTs...)> {
+private:
+   using Helper = engineAPI::detail::ThunkHelpers<startArgc, void, ArgTs...>;
+   using SeqType = typename Helper::SeqType;
+public:
+   typedef typename Helper::FunctionType FunctionType;
+   typedef typename Helper::ReturnType ReturnType;
+   template<typename Frame> using MethodType = typename Helper::template MethodType<Frame>;
+   static const S32 NUM_ARGS = Helper::NUM_ARGS;
+   
+   static void thunk( S32 argc, ConsoleValueRef *argv, FunctionType fn, const _EngineFunctionDefaultArguments< void(ArgTs...) >& defaultArgs)
    {
-      char data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< H >::ArgumentValueType ) ];
-
-      typename EngineTypeTraits< A >::ValueType a() const
-      {
-         return EngineTypeTraits< A >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< A >::ArgumentValueType* >
-               ( &data[ 0 ] ) ) );
-      }
+      Helper::dispatchHelper(argc, argv, fn, defaultArgs, SeqType());
+   }
+   template< typename Frame >
+   static void thunk( S32 argc, ConsoleValueRef *argv, MethodType<Frame> fn, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, ArgTs...) >& defaultArgs)
+   {
+      Helper::dispatchHelper(argc, argv, fn, frame, defaultArgs, SeqType());
+   }
+};
 
-      typename EngineTypeTraits< B >::ValueType b() const
-      {
-         return EngineTypeTraits< B >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< B >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) ] ) ) );
-      }
 
-      typename EngineTypeTraits< C >::ValueType c() const
-      {
-         return EngineTypeTraits< C >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< C >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) ] ) ) );
-      }
+/// @}
 
-      typename EngineTypeTraits< D >::ValueType d() const
-      {
-         return EngineTypeTraits< D >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< D >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) ] ) ) );
-      }
+/// @name API Definition Macros
+///
+/// The macros in this group allow to create engine API functions that work both with the
+/// legacy console system as well as with the new engine export system.  As such, they only
+/// support those function features that are available in both systems.  This means that for
+/// console-style variadic functions, the ConsoleXXX must be used and that for overloaded
+/// and/or C-style variadic functions as well as for placing functions in export scopes,
+/// DEFINE_CALLIN must be used directly.
+///
+/// When the console system is removed, the console thunking functionality will be removed
+/// from these macros but otherwise they will remain unchanged and in place.
+///
+/// @{
 
-      typename EngineTypeTraits< E >::ValueType e() const
-      {
-         return EngineTypeTraits< E >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< E >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) ] ) ) );
-      }
 
-      typename EngineTypeTraits< F >::ValueType f() const
-      {
-         return EngineTypeTraits< F >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< F >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) ] ) ) );
-      }
+// Helpers to implement initialization checks.  Pulled out into separate macros so this can be deactivated easily.
+// Especially important for the initialize() function itself.
 
-      typename EngineTypeTraits< G >::ValueType g() const
-      {
-         return EngineTypeTraits< G >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< G >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) ] ) ) );
+#define _CHECK_ENGINE_INITIALIZED_IMPL( fnName, returnType )                                                                     \
+      if( !engineAPI::gIsInitialized )                                                                                           \
+      {                                                                                                                          \
+         Con::errorf( "EngineAPI: Engine not initialized when calling " #fnName );                                               \
+         return EngineTypeTraits< returnType >::ReturnValue( EngineTypeTraits< returnType >::ReturnValueType() );                \
       }
 
-      typename EngineTypeTraits< H >::ValueType h() const
-      {
-         return EngineTypeTraits< H >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< H >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) ] ) ) );
-      }
-   };
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
-struct _EngineTrampoline< R( A, B, C, D, E, F, G, H, I ) >
-{
-   struct Args
-   {
-      char data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< H >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< I >::ArgumentValueType ) ];
-
-      typename EngineTypeTraits< A >::ValueType a() const
-      {
-         return EngineTypeTraits< A >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< A >::ArgumentValueType* >
-               ( &data[ 0 ] ) ) );
-      }
-
-      typename EngineTypeTraits< B >::ValueType b() const
-      {
-         return EngineTypeTraits< B >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< B >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< C >::ValueType c() const
-      {
-         return EngineTypeTraits< C >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< C >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< D >::ValueType d() const
-      {
-         return EngineTypeTraits< D >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< D >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< E >::ValueType e() const
-      {
-         return EngineTypeTraits< E >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< E >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< F >::ValueType f() const
-      {
-         return EngineTypeTraits< F >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< F >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< G >::ValueType g() const
-      {
-         return EngineTypeTraits< G >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< G >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< H >::ValueType h() const
-      {
-         return EngineTypeTraits< H >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< H >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< I >::ValueType i() const
-      {
-         return EngineTypeTraits< I >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< I >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< H >::ArgumentValueType ) ] ) ) );
-      }
-   };
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J >
-struct _EngineTrampoline< R( A, B, C, D, E, F, G, H, I, J ) >
-{
-   struct Args
-   {
-      char data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< H >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< I >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< J >::ArgumentValueType ) ];
-
-      typename EngineTypeTraits< A >::ValueType a() const
-      {
-         return EngineTypeTraits< A >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< A >::ArgumentValueType* >
-               ( &data[ 0 ] ) ) );
-      }
-
-      typename EngineTypeTraits< B >::ValueType b() const
-      {
-         return EngineTypeTraits< B >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< B >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< C >::ValueType c() const
-      {
-         return EngineTypeTraits< C >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< C >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< D >::ValueType d() const
-      {
-         return EngineTypeTraits< D >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< D >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< E >::ValueType e() const
-      {
-         return EngineTypeTraits< E >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< E >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< F >::ValueType f() const
-      {
-         return EngineTypeTraits< F >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< F >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< G >::ValueType g() const
-      {
-         return EngineTypeTraits< G >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< G >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< H >::ValueType h() const
-      {
-         return EngineTypeTraits< H >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< H >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< I >::ValueType i() const
-      {
-         return EngineTypeTraits< I >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< I >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< H >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< J >::ValueType j() const
-      {
-         return EngineTypeTraits< J >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< J >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< H >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< I >::ArgumentValueType ) ] ) ) );
-      }
-   };
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K >
-struct _EngineTrampoline< R( A, B, C, D, E, F, G, H, I, J, K ) >
-{
-   struct Args
-   {
-      char data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< H >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< I >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< J >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< K >::ArgumentValueType ) ];
-
-      typename EngineTypeTraits< A >::ValueType a() const
-      {
-         return EngineTypeTraits< A >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< A >::ArgumentValueType* >
-               ( &data[ 0 ] ) ) );
-      }
-
-      typename EngineTypeTraits< B >::ValueType b() const
-      {
-         return EngineTypeTraits< B >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< B >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< C >::ValueType c() const
-      {
-         return EngineTypeTraits< C >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< C >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< D >::ValueType d() const
-      {
-         return EngineTypeTraits< D >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< D >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< E >::ValueType e() const
-      {
-         return EngineTypeTraits< E >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< E >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< F >::ValueType f() const
-      {
-         return EngineTypeTraits< F >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< F >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< G >::ValueType g() const
-      {
-         return EngineTypeTraits< G >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< G >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< H >::ValueType h() const
-      {
-         return EngineTypeTraits< H >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< H >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< I >::ValueType i() const
-      {
-         return EngineTypeTraits< I >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< I >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< H >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< J >::ValueType j() const
-      {
-         return EngineTypeTraits< J >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< J >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< H >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< I >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< K >::ValueType k() const
-      {
-         return EngineTypeTraits< K >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< K >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< H >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< I >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< J >::ArgumentValueType ) ] ) ) );
-      }
-   };
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L >
-struct _EngineTrampoline< R( A, B, C, D, E, F, G, H, I, J, K, L ) >
-{
-   struct Args
-   {
-      char data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< H >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< I >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< J >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< K >::ArgumentValueType ) +
-                 sizeof( typename EngineTypeTraits< L >::ArgumentValueType ) ];
-
-      typename EngineTypeTraits< A >::ValueType a() const
-      {
-         return EngineTypeTraits< A >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< A >::ArgumentValueType* >
-               ( &data[ 0 ] ) ) );
-      }
-
-      typename EngineTypeTraits< B >::ValueType b() const
-      {
-         return EngineTypeTraits< B >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< B >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< C >::ValueType c() const
-      {
-         return EngineTypeTraits< C >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< C >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< D >::ValueType d() const
-      {
-         return EngineTypeTraits< D >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< D >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< E >::ValueType e() const
-      {
-         return EngineTypeTraits< E >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< E >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< F >::ValueType f() const
-      {
-         return EngineTypeTraits< F >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< F >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< G >::ValueType g() const
-      {
-         return EngineTypeTraits< G >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< G >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< H >::ValueType h() const
-      {
-         return EngineTypeTraits< H >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< H >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< I >::ValueType i() const
-      {
-         return EngineTypeTraits< I >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< I >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< H >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< J >::ValueType j() const
-      {
-         return EngineTypeTraits< J >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< J >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< H >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< I >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< K >::ValueType k() const
-      {
-         return EngineTypeTraits< K >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< K >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< H >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< I >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< J >::ArgumentValueType ) ] ) ) );
-      }
-
-      typename EngineTypeTraits< L >::ValueType l() const
-      {
-         return EngineTypeTraits< L >::ArgumentToValue(
-            *( reinterpret_cast< const typename EngineTypeTraits< L >::ArgumentValueType* >
-               ( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< C >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< D >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< E >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< F >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< G >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< H >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< I >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< J >::ArgumentValueType ) +
-                        sizeof( typename EngineTypeTraits< K >::ArgumentValueType ) ] ) ) );
-      }
-   };
-};
-
-
-template< typename T >
-struct _EngineFunctionTrampolineBase : public _EngineTrampoline< T >
-{
-   typedef T FunctionType;
-};
-
-// Trampolines for any call-ins that aren't methods.
-template< typename T >
-struct _EngineFunctionTrampoline {};
-
-template< typename R >
-struct _EngineFunctionTrampoline< R() > : public _EngineFunctionTrampolineBase< R() >
-{
-   static R jmp( R ( *fn )(), const typename _EngineFunctionTrampolineBase< R() >::Args& args )
-   {
-      return R( fn() );
-   }
-};
-
-
-template< typename R, typename A >
-struct _EngineFunctionTrampoline< R( A ) > : public _EngineFunctionTrampolineBase< R( A ) >
-{
-   static R jmp( R ( *fn )( A ), const typename _EngineFunctionTrampolineBase< R( A ) >::Args& args )
-   {
-      return R( fn( args.a() ) );
-   }
-};
-
-template< typename R, typename A, typename B >
-struct _EngineFunctionTrampoline< R( A, B ) > : public _EngineFunctionTrampolineBase< R( A, B ) >
-{
-   static R jmp( R ( *fn )( A, B ), const typename _EngineFunctionTrampolineBase< R( A, B ) >::Args& args )
-   {
-      return R( fn( args.a(), args.b() ) );
-   }
-};
-
-template< typename R, typename A, typename B, typename C >
-struct _EngineFunctionTrampoline< R( A, B, C ) > : public _EngineFunctionTrampolineBase< R( A, B, C ) >
-{
-   static R jmp( R ( *fn )( A, B, C ), const typename _EngineFunctionTrampolineBase< R( A, B, C ) >::Args& args )
-   {
-      return R( fn( args.a(), args.b(), args.c() ) );
-   }
-};
-
-template< typename R, typename A, typename B, typename C, typename D >
-struct _EngineFunctionTrampoline< R( A, B, C, D ) > : public _EngineFunctionTrampolineBase< R( A, B, C, D ) >
-{
-   static R jmp( R ( *fn )( A, B, C, D ), const typename _EngineFunctionTrampolineBase< R( A, B, C, D ) >::Args& args )
-   {
-      return R( fn( args.a(), args.b(), args.c(), args.d() ) );
-   }
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E >
-struct _EngineFunctionTrampoline< R( A, B, C, D, E ) > : public _EngineFunctionTrampolineBase< R( A, B, C, D, E ) >
-{
-   static R jmp( R ( *fn )( A, B, C, D, E ), const typename _EngineFunctionTrampolineBase< R( A, B, C, D, E ) >::Args& args )
-   {
-      return R( fn( args.a(), args.b(), args.c(), args.d(), args.e() ) );
-   }
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F >
-struct _EngineFunctionTrampoline< R( A, B, C, D, E, F ) > : public _EngineFunctionTrampolineBase< R( A, B, C, D, E, F ) >
-{
-   static R jmp( R ( *fn )( A, B, C, D, E, F ), const typename _EngineFunctionTrampolineBase< R( A, B, C, D, E, F ) >::Args& args )
-   {
-      return R( fn( args.a(), args.b(), args.c(), args.d(), args.e(), args.f() ) );
-   }
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-struct _EngineFunctionTrampoline< R( A, B, C, D, E, F, G ) > : public _EngineFunctionTrampolineBase< R( A, B, C, D, E, F, G ) >
-{
-   static R jmp( R ( *fn )( A, B, C, D, E, F, G ), const typename _EngineFunctionTrampolineBase< R( A, B, C, D, E, F, G ) >::Args& args )
-   {
-      return R( fn( args.a(), args.b(), args.c(), args.d(), args.e(), args.f(), args.g() ) );
-   }
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-struct _EngineFunctionTrampoline< R( A, B, C, D, E, F, G, H ) > : public _EngineFunctionTrampolineBase< R( A, B, C, D, E, F, G, H ) >
-{
-   static R jmp( R ( *fn )( A, B, C, D, E, F, G, H ), const typename _EngineFunctionTrampolineBase< R( A, B, C, D, E, F, G, H ) >::Args& args )
-   {
-      return R( fn( args.a(), args.b(), args.c(), args.d(), args.e(), args.f(), args.g(), args.h() ) );
-   }
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
-struct _EngineFunctionTrampoline< R( A, B, C, D, E, F, G, H, I ) > : public _EngineFunctionTrampolineBase< R( A, B, C, D, E, F, G, H, I ) >
-{
-   static R jmp( R ( *fn )( A, B, C, D, E, F, G, H, I ), const typename _EngineFunctionTrampolineBase< R( A, B, C, D, E, F, G, H, I ) >::Args& args )
-   {
-      return R( fn( args.a(), args.b(), args.c(), args.d(), args.e(), args.f(), args.g(), args.h(), args.i() ) );
-   }
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J >
-struct _EngineFunctionTrampoline< R( A, B, C, D, E, F, G, H, I, J ) > : public _EngineFunctionTrampolineBase< R( A, B, C, D, E, F, G, H, I, J ) >
-{
-   static R jmp( R ( *fn )( A, B, C, D, E, F, G, H, I, J ), const typename _EngineFunctionTrampolineBase< R( A, B, C, D, E, F, G, H, I, J ) >::Args& args )
-   {
-      return R( fn( args.a(), args.b(), args.c(), args.d(), args.e(), args.f(), args.g(), args.h(), args.i(), args.j() ) );
-   }
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K >
-struct _EngineFunctionTrampoline< R( A, B, C, D, E, F, G, H, I, J, K ) > : public _EngineFunctionTrampolineBase< R( A, B, C, D, E, F, G, H, I, J, K ) >
-{
-   static R jmp( R ( *fn )( A, B, C, D, E, F, G, H, I, J, K ), const typename _EngineFunctionTrampolineBase< R( A, B, C, D, E, F, G, H, I, J, K ) >::Args& args )
-   {
-      return R( fn( args.a(), args.b(), args.c(), args.d(), args.e(), args.f(), args.g(), args.h(), args.i(), args.j(), args.k() ) );
-   }
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L >
-struct _EngineFunctionTrampoline< R( A, B, C, D, E, F, G, H, I, J, K, L ) > : public _EngineFunctionTrampolineBase< R( A, B, C, D, E, F, G, H, I, J, K, L ) >
-{
-   static R jmp( R ( *fn )( A, B, C, D, E, F, G, H, I, J, K, L ), const typename _EngineFunctionTrampolineBase< R( A, B, C, D, E, F, G, H, I, J, K, L ) >::Args& args )
-   {
-      return R( fn( args.a(), args.b(), args.c(), args.d(), args.e(), args.f(), args.g(), args.h(), args.i(), args.j(), args.k(), args.l() ) );
-   }
-};
-
-
-// Trampolines for engine methods
-
-template< typename T >
-struct _EngineMethodTrampolineBase : public _EngineTrampoline< T > {};
-
-template< typename Frame, typename T >
-struct _EngineMethodTrampoline {};
-
-template< typename Frame, typename R >
-struct _EngineMethodTrampoline< Frame, R() > : public _EngineMethodTrampolineBase< R() >
-{
-   typedef R( FunctionType )( typename Frame::ObjectType* );
-   static R jmp( typename Frame::ObjectType* object, const typename _EngineFunctionTrampolineBase< R() >::Args& args )
-   {
-      Frame f;
-      f.object = object;
-      return R( f._exec() );
-   }
-};
-
-
-template< typename Frame, typename R, typename A >
-struct _EngineMethodTrampoline< Frame, R( A ) > : public _EngineMethodTrampolineBase< R( A ) >
-{
-   typedef R( FunctionType )( typename Frame::ObjectType*, A );
-   static R jmp( typename Frame::ObjectType* object, const typename _EngineFunctionTrampolineBase< R( A ) >::Args& args )
-   {
-      Frame f;
-      f.object = object;
-      return R( f._exec( args.a() ) );
-   }
-};
-
-template< typename Frame, typename R, typename A, typename B >
-struct _EngineMethodTrampoline< Frame, R( A, B ) > : public _EngineMethodTrampolineBase< R( A, B ) >
-{
-   typedef R( FunctionType )( typename Frame::ObjectType*, A, B );
-   static R jmp( typename Frame::ObjectType* object, const typename _EngineFunctionTrampolineBase< R( A, B ) >::Args& args )
-   {
-      Frame f;
-      f.object = object;
-      return R( f._exec( args.a(), args.b() ) );
-   }
-};
-
-template< typename Frame, typename R, typename A, typename B, typename C >
-struct _EngineMethodTrampoline< Frame, R( A, B, C ) > : public _EngineMethodTrampolineBase< R( A, B, C ) >
-{
-   typedef R( FunctionType )( typename Frame::ObjectType*, A, B, C );
-   static R jmp( typename Frame::ObjectType* object, const typename _EngineFunctionTrampolineBase< R( A, B, C ) >::Args& args )
-   {
-      Frame f;
-      f.object = object;
-      return R( f._exec( args.a(), args.b(), args.c() ) );
-   }
-};
-
-template< typename Frame, typename R, typename A, typename B, typename C, typename D >
-struct _EngineMethodTrampoline< Frame, R( A, B, C, D ) > : public _EngineMethodTrampolineBase< R( A, B, C, D ) >
-{
-   typedef R( FunctionType )( typename Frame::ObjectType*, A, B, C, D );
-   static R jmp( typename Frame::ObjectType* object, const typename _EngineFunctionTrampolineBase< R( A, B, C, D ) >::Args& args )
-   {
-      Frame f;
-      f.object = object;
-      return R( f._exec( args.a(), args.b(), args.c(), args.d() ) );
-   }
-};
-
-template< typename Frame, typename R, typename A, typename B, typename C, typename D, typename E >
-struct _EngineMethodTrampoline< Frame, R( A, B, C, D, E ) > : public _EngineMethodTrampolineBase< R( A, B, C, D, E ) >
-{
-   typedef R( FunctionType )( typename Frame::ObjectType*, A, B, C, D, E );
-   static R jmp( typename Frame::ObjectType* object, const typename _EngineFunctionTrampolineBase< R( A, B, C, D, E ) >::Args& args )
-   {
-      Frame f;
-      f.object = object;
-      return R( f._exec( args.a(), args.b(), args.c(), args.d(), args.e() ) );
-   }
-};
-
-template< typename Frame, typename R, typename A, typename B, typename C, typename D, typename E, typename F >
-struct _EngineMethodTrampoline< Frame, R( A, B, C, D, E, F ) > : public _EngineMethodTrampolineBase< R( A, B, C, D, E, F ) >
-{
-   typedef R( FunctionType )( typename Frame::ObjectType*, A, B, C, D, E, F );
-   static R jmp( typename Frame::ObjectType* object, const typename _EngineFunctionTrampolineBase< R( A, B, C, D, E, F ) >::Args& args )
-   {
-      Frame f;
-      f.object = object;
-      return R( f._exec( args.a(), args.b(), args.c(), args.d(), args.e(), args.f() ) );
-   }
-};
-
-template< typename Frame, typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-struct _EngineMethodTrampoline< Frame, R( A, B, C, D, E, F, G ) > : public _EngineMethodTrampolineBase< R( A, B, C, D, E, F, G ) >
-{
-   typedef R( FunctionType )( typename Frame::ObjectType*, A, B, C, D, E, F, G );
-   static R jmp( typename Frame::ObjectType* object, const typename _EngineFunctionTrampolineBase< R( A, B, C, D, E, F, G ) >::Args& args )
-   {
-      Frame f;
-      f.object = object;
-      return R( f._exec( args.a(), args.b(), args.c(), args.d(), args.e(), args.f(), args.g() ) );
-   }
-};
-
-template< typename Frame, typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-struct _EngineMethodTrampoline< Frame, R( A, B, C, D, E, F, G, H ) > : public _EngineMethodTrampolineBase< R( A, B, C, D, E, F, G, H ) >
-{
-   typedef R( FunctionType )( typename Frame::ObjectType*, A, B, C, D, E, F, G, H );
-   static R jmp( typename Frame::ObjectType* object, const typename _EngineFunctionTrampolineBase< R( A, B, C, D, E, F, G, H ) >::Args& args )
-   {
-      Frame f;
-      f.object = object;
-      return R( f._exec( args.a(), args.b(), args.c(), args.d(), args.e(), args.f(), args.g(), args.h() ) );
-   }
-};
-
-template< typename Frame, typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
-struct _EngineMethodTrampoline< Frame, R( A, B, C, D, E, F, G, H, I ) > : public _EngineMethodTrampolineBase< R( A, B, C, D, E, F, G, H, I ) >
-{
-   typedef R( FunctionType )( typename Frame::ObjectType*, A, B, C, D, E, F, G, H, I );
-   static R jmp( typename Frame::ObjectType* object, const typename _EngineFunctionTrampolineBase< R( A, B, C, D, E, F, G, H, I ) >::Args& args )
-   {
-      Frame f;
-      f.object = object;
-      return R( f._exec( args.a(), args.b(), args.c(), args.d(), args.e(), args.f(), args.g(), args.h(), args.i() ) );
-   }
-};
-
-template< typename Frame, typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J >
-struct _EngineMethodTrampoline< Frame, R( A, B, C, D, E, F, G, H, I, J ) > : public _EngineMethodTrampolineBase< R( A, B, C, D, E, F, G, H, I, J ) >
-{
-   typedef R( FunctionType )( typename Frame::ObjectType*, A, B, C, D, E, F, G, H, I, J );
-   static R jmp( typename Frame::ObjectType* object, const typename _EngineFunctionTrampolineBase< R( A, B, C, D, E, F, G, H, I, J ) >::Args& args )
-   {
-      Frame f;
-      f.object = object;
-      return R( f._exec( args.a(), args.b(), args.c(), args.d(), args.e(), args.f(), args.g(), args.h(), args.i(), args.j() ) );
-   }
-};
-
-template< typename Frame, typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K >
-struct _EngineMethodTrampoline< Frame, R( A, B, C, D, E, F, G, H, I, J, K ) > : public _EngineMethodTrampolineBase< R( A, B, C, D, E, F, G, H, I, J, K ) >
-{
-   typedef R( FunctionType )( typename Frame::ObjectType*, A, B, C, D, E, F, G, H, I, J, K );
-   static R jmp( typename Frame::ObjectType* object, const typename _EngineFunctionTrampolineBase< R( A, B, C, D, E, F, G, H, I, J, K ) >::Args& args )
-   {
-      Frame f;
-      f.object = object;
-      return R( f._exec( args.a(), args.b(), args.c(), args.d(), args.e(), args.f(), args.g(), args.h(), args.i(), args.j(), args.k() ) );
-   }
-};
-
-template< typename Frame, typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L >
-struct _EngineMethodTrampoline< Frame, R( A, B, C, D, E, F, G, H, I, J, K, L ) > : public _EngineMethodTrampolineBase< R( A, B, C, D, E, F, G, H, I, J, K, L ) >
-{
-   typedef R( FunctionType )( typename Frame::ObjectType*, A, B, C, D, E, F, G, H, I, J, K, L );
-   static R jmp( typename Frame::ObjectType* object, const typename _EngineFunctionTrampolineBase< R( A, B, C, D, E, F, G, H, I, J, K, L ) >::Args& args )
-   {
-      Frame f;
-      f.object = object;
-      return R( f._exec( args.a(), args.b(), args.c(), args.d(), args.e(), args.f(), args.g(), args.h(), args.i(), args.j(), args.k(), args.l() ) );
-   }
-};
-
-
-
-/// @}
-
-
-/// @name Thunking
-///
-/// Internal functionality for thunks placed between TorqueScript calls of engine functions and their native
-/// implementations.
-///
-/// @note The functionality in this group is specific to the console interop system.
-/// @{
-
-
-// Helper function to return data from a thunk.
-template< typename T >
-inline const char* _EngineConsoleThunkReturnValue( const T& value )
-{
-   return EngineMarshallData( value );
-}
-inline bool _EngineConsoleThunkReturnValue( bool value )
-{
-   return value;
-}
-inline S32 _EngineConsoleThunkReturnValue( S32 value )
-{
-   return value;
-}
-inline F32 _EngineConsoleThunkReturnValue( F32 value )
-{
-   return value;
-}
-inline const char* _EngineConsoleThunkReturnValue( const String& str )
-{
-   return Con::getReturnBuffer( str );
-}
-inline const char* _EngineConsoleThunkReturnValue( const char* value )
-{
-   return EngineMarshallData( value );
-}
-template< typename T >
-inline const char* _EngineConsoleThunkReturnValue( T* value )
-{
-   return ( value ? value->getIdString() : "" );
-}
-template< typename T >
-inline const char* _EngineConsoleThunkReturnValue( const T* value )
-{
-   return ( value ? value->getIdString() : "" );
-}
-
-
-
-// Helper class to determine the type of callback registered with the console system.
-template< typename R >
-struct _EngineConsoleThunkType
-{
-   typedef const char* ReturnType;
-   typedef StringCallback CallbackType;
-};
-template<>
-struct _EngineConsoleThunkType< S32 >
-{
-   typedef S32 ReturnType;
-   typedef IntCallback CallbackType;
-};
-template<>
-struct _EngineConsoleThunkType< U32 >
-{
-   typedef U32 ReturnType;
-   typedef IntCallback CallbackType;
-};
-template<>
-struct _EngineConsoleThunkType< F32 >
-{
-   typedef F32 ReturnType;
-   typedef FloatCallback CallbackType;
-};
-template<>
-struct _EngineConsoleThunkType< bool >
-{
-   typedef bool ReturnType;
-   typedef BoolCallback CallbackType;
-};
-template<>
-struct _EngineConsoleThunkType< void >
-{
-   typedef void ReturnType;
-   typedef VoidCallback CallbackType;
-};
-
-
-// Helper struct to count the number of parameters in a function list.
-// The setup through operator () allows omitting the the argument list entirely.
-struct _EngineConsoleThunkCountArgs
-{
-
-   template< typename A >
-   U32 operator ()( A a )
-   {
-      return 1;
-   }
-
-   template< typename A, typename B >
-   U32 operator ()( A a, B b )
-   {
-      return 2;
-   }
-
-   template< typename A, typename B, typename C >
-   U32 operator ()( A a, B b, C c )
-   {
-      return 3;
-   }
-
-   template< typename A, typename B, typename C, typename D >
-   U32 operator ()( A a, B b, C c, D d )
-   {
-      return 4;
-   }
-
-   template< typename A, typename B, typename C, typename D, typename E >
-   U32 operator ()( A a, B b, C c, D d, E e )
-   {
-      return 5;
-   }
-
-   template< typename A, typename B, typename C, typename D, typename E, typename F >
-   U32 operator ()( A a, B b, C c, D d, E e, F f )
-   {
-      return 6;
-   }
-
-   template< typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-   U32 operator ()( A a, B b, C c, D d, E e, F f, G g )
-   {
-      return 7;
-   }
-
-   template< typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-   U32 operator ()( A a, B b, C c, D d, E e, F f, G g, H h )
-   {
-      return 8;
-   }
-
-   template< typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
-   U32 operator ()( A a, B b, C c, D d, E e, F f, G g, H h, I i )
-   {
-      return 9;
-   }
-
-   template< typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J >
-   U32 operator ()( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j )
-   {
-      return 10;
-   }
-
-   template< typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K >
-   U32 operator ()( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k )
-   {
-      return 11;
-   }
-
-   template< typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L >
-   U32 operator ()( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l )
-   {
-      return 12;
-   }
-
-   
-   operator U32() const
-   {
-      return 0;
-   }
-};
-
-
-
-
-// Encapsulation of a legacy console function invocation.
-
-template< S32 startArgc, typename T >
-struct _EngineConsoleThunk {};
-
-template< S32 startArgc, typename R >
-struct _EngineConsoleThunk< startArgc, R() >
-{
-   typedef typename _EngineConsoleThunkType< R >::ReturnType ReturnType;
-   static const S32 NUM_ARGS = 0;
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( *fn )(), const _EngineFunctionDefaultArguments< void() >& )
-   {
-      return _EngineConsoleThunkReturnValue( fn() );
-   }
-   template< typename Frame >
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( Frame::*fn )() const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType* ) >& )
-   {
-      return _EngineConsoleThunkReturnValue( ( frame->*fn )() );
-   }
-};
-
-template< S32 startArgc >
-struct _EngineConsoleThunk< startArgc, void() >
-{
-   typedef void ReturnType;
-   static const S32 NUM_ARGS = 0;
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( *fn )(), const _EngineFunctionDefaultArguments< void() >& )
-   {
-      fn();
-   }
-   template< typename Frame >
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( Frame::*fn )() const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType* ) >& )
-   {
-      return ( frame->*fn )();
-   }
-};
-
-
-
-template< S32 startArgc, typename R, typename A >
-struct _EngineConsoleThunk< startArgc, R( A ) >
-{
-   typedef typename _EngineConsoleThunkType< R >::ReturnType ReturnType;
-   static const S32 NUM_ARGS = 1 + startArgc;
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( *fn )( A ), const _EngineFunctionDefaultArguments< void( A ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      
-      return _EngineConsoleThunkReturnValue( fn( a ) );
-   }
-   template< typename Frame >
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( Frame::*fn )( A ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      
-      return _EngineConsoleThunkReturnValue( ( frame->*fn )( a ) );
-   }
-};
-
-template< S32 startArgc, typename A >
-struct _EngineConsoleThunk< startArgc, void( A ) >
-{
-   typedef void ReturnType;
-   static const S32 NUM_ARGS = 1 + startArgc;
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( *fn )( A ), const _EngineFunctionDefaultArguments< void( A ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      
-      fn( a );
-   }
-   template< typename Frame >
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( Frame::*fn )( A ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      
-      ( frame->*fn )( a );
-   }
-};
-
-
-template< S32 startArgc, typename R, typename A, typename B >
-struct _EngineConsoleThunk< startArgc, R( A, B ) >
-{
-   typedef typename _EngineConsoleThunkType< R >::ReturnType ReturnType;
-   static const S32 NUM_ARGS = 2 + startArgc;
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( *fn )( A, B ), const _EngineFunctionDefaultArguments< void( A, B ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      
-      return _EngineConsoleThunkReturnValue( fn( a, b ) );
-   }
-   template< typename Frame >
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( Frame::*fn )( A, B ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      
-      return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b ) );
-   }
-};
-
-template< S32 startArgc, typename A, typename B >
-struct _EngineConsoleThunk< startArgc, void( A, B ) >
-{
-   typedef void ReturnType;
-   static const S32 NUM_ARGS = 2 + startArgc;
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( *fn )( A, B ), const _EngineFunctionDefaultArguments< void( A, B ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      
-      fn( a, b );
-   }
-   template< typename Frame >
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( Frame::*fn )( A, B ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      
-      ( frame->*fn )( a, b );
-   }
-};
-
-
-template< S32 startArgc, typename R, typename A, typename B, typename C >
-struct _EngineConsoleThunk< startArgc, R( A, B, C ) >
-{
-   typedef typename _EngineConsoleThunkType< R >::ReturnType ReturnType;
-   static const S32 NUM_ARGS = 3 + startArgc;
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( *fn )( A, B, C ), const _EngineFunctionDefaultArguments< void( A, B, C ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      
-      return _EngineConsoleThunkReturnValue( fn( a, b, c ) );
-   }
-   template< typename Frame >
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( Frame::*fn )( A, B, C ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      
-      return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c ) );
-   }
-};
-
-template< S32 startArgc, typename A, typename B, typename C >
-struct _EngineConsoleThunk< startArgc, void( A, B, C ) >
-{
-   typedef void ReturnType;
-   static const S32 NUM_ARGS = 3 + startArgc;
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( *fn )( A, B, C ), const _EngineFunctionDefaultArguments< void( A, B, C ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      
-      fn( a, b, c );
-   }
-   template< typename Frame >
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( Frame::*fn )( A, B, C ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      
-      ( frame->*fn )( a, b, c );
-   }
-};
-
-
-template< S32 startArgc, typename R, typename A, typename B, typename C, typename D >
-struct _EngineConsoleThunk< startArgc, R( A, B, C, D ) >
-{
-   typedef typename _EngineConsoleThunkType< R >::ReturnType ReturnType;
-   static const S32 NUM_ARGS = 4 + startArgc;
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( *fn )( A, B, C, D ), const _EngineFunctionDefaultArguments< void( A, B, C, D ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.d ) );
-      
-      return _EngineConsoleThunkReturnValue( fn( a, b, c, d ) );
-   }
-   template< typename Frame >
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( Frame::*fn )( A, B, C, D ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C, D ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.e ) );
-      
-      return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c, d ) );
-   }
-};
-
-template< S32 startArgc, typename A, typename B, typename C, typename D >
-struct _EngineConsoleThunk< startArgc, void( A, B, C, D ) >
-{
-   typedef void ReturnType;
-   static const S32 NUM_ARGS = 4 + startArgc;
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( *fn )( A, B, C, D ), const _EngineFunctionDefaultArguments< void( A, B, C, D ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.d ) );
-      
-      fn( a, b, c, d );
-   }
-   template< typename Frame >
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( Frame::*fn )( A, B, C, D ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C, D ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.e ) );
-      
-      ( frame->*fn )( a, b, c, d );
-   }
-};
-
-
-template< S32 startArgc, typename R, typename A, typename B, typename C, typename D, typename E >
-struct _EngineConsoleThunk< startArgc, R( A, B, C, D, E ) >
-{
-   typedef typename _EngineConsoleThunkType< R >::ReturnType ReturnType;
-   static const S32 NUM_ARGS = 5 + startArgc;
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( *fn )( A, B, C, D, E ), const _EngineFunctionDefaultArguments< void( A, B, C, D, E ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.d ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.e ) );
-      
-      return _EngineConsoleThunkReturnValue( fn( a, b, c, d, e ) );
-   }
-   template< typename Frame >
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( Frame::*fn )( A, B, C, D, E ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C, D, E ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.e ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.f ) );
-      
-      return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c, d, e ) );
-   }
-};
-
-template< S32 startArgc, typename A, typename B, typename C, typename D, typename E >
-struct _EngineConsoleThunk< startArgc, void( A, B, C, D, E ) >
-{
-   typedef void ReturnType;
-   static const S32 NUM_ARGS = 5 + startArgc;
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( *fn )( A, B, C, D, E ), const _EngineFunctionDefaultArguments< void( A, B, C, D, E ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.d ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.e ) );
-      
-      fn( a, b, c, d, e );
-   }
-   template< typename Frame >
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( Frame::*fn )( A, B, C, D, E ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C, D, E ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.e ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.f ) );
-      
-      ( frame->*fn )( a, b, c, d, e );
-   }
-};
-
-
-template< S32 startArgc, typename R, typename A, typename B, typename C, typename D, typename E, typename F >
-struct _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F ) >
-{
-   typedef typename _EngineConsoleThunkType< R >::ReturnType ReturnType;
-   static const S32 NUM_ARGS = 6 + startArgc;
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( *fn )( A, B, C, D, E, F ), const _EngineFunctionDefaultArguments< void( A, B, C, D, E, F ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.d ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.e ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.f ) );
-      
-      return _EngineConsoleThunkReturnValue( fn( a, b, c, d, e, f ) );
-   }
-   template< typename Frame >
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( Frame::*fn )( A, B, C, D, E, F ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C, D, E, F ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.e ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.f ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.g ) );
-      
-      return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c, d, e, f ) );
-   }
-};
-
-template< S32 startArgc, typename A, typename B, typename C, typename D, typename E, typename F >
-struct _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F ) >
-{
-   typedef void ReturnType;
-   static const S32 NUM_ARGS = 6 + startArgc;
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( *fn )( A, B, C, D, E, F ), const _EngineFunctionDefaultArguments< void( A, B, C, D, E, F ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.d ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.e ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.f ) );
-      
-      fn( a, b, c, d, e, f );
-   }
-   template< typename Frame >
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( Frame::*fn )( A, B, C, D, E, F ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C, D, E, F ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.e ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.f ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.g ) );
-      
-      ( frame->*fn )( a, b, c, d, e, f );
-   }
-};
-
-
-template< S32 startArgc, typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-struct _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F, G ) >
-{
-   typedef typename _EngineConsoleThunkType< R >::ReturnType ReturnType;
-   static const S32 NUM_ARGS = 7 + startArgc;
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( *fn )( A, B, C, D, E, F, G ), const _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.d ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.e ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.f ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.g ) );
-      
-      return _EngineConsoleThunkReturnValue( fn( a, b, c, d, e, f, g ) );
-   }
-   template< typename Frame >
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( Frame::*fn )( A, B, C, D, E, F, G ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C, D, E, F, G ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.e ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.f ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.g ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.h ) );
-      
-      return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c, d, e, f, g ) );
-   }
-};
-
-template< S32 startArgc, typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-struct _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F, G ) >
-{
-   typedef void ReturnType;
-   static const S32 NUM_ARGS = 7 + startArgc;
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( *fn )( A, B, C, D, E, F, G ), const _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.d ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.e ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.f ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.g ) );
-      
-      fn( a, b, c, d, e, f, g );
-   }
-   template< typename Frame >
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( Frame::*fn )( A, B, C, D, E, F, G ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C, D, E, F, G ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.e ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.f ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.g ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.h ) );
-      
-      ( frame->*fn )( a, b, c, d, e, f, g );
-   }
-};
-
-
-template< S32 startArgc, typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-struct _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F, G, H ) >
-{
-   typedef typename _EngineConsoleThunkType< R >::ReturnType ReturnType;
-   static const S32 NUM_ARGS = 8 + startArgc;
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( *fn )( A, B, C, D, E, F, G, H ), const _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.d ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.e ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.f ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.g ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.h ) );
-      
-      return _EngineConsoleThunkReturnValue( fn( a, b, c, d, e, f, g, h ) );
-   }
-   template< typename Frame >
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( Frame::*fn )( A, B, C, D, E, F, G, H ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C, D, E, F, G, H ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.e ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.f ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.g ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.h ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.i ) );
-      
-      return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c, d, e, f, g, h ) );
-   }
-};
-
-template< S32 startArgc, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-struct _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F, G, H ) >
-{
-   typedef void ReturnType;
-   static const S32 NUM_ARGS = 8 + startArgc;
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( *fn )( A, B, C, D, E, F, G, H ), const _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.d ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.e ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.f ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.g ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.h ) );
-      
-      fn( a, b, c, d, e, f, g, h );
-   }
-   template< typename Frame >
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( Frame::*fn )( A, B, C, D, E, F, G, H ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C, D, E, F, G, H ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.e ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.f ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.g ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.h ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.i ) );
-      
-      ( frame->*fn )( a, b, c, d, e, f, g, h );
-   }
-};
-
-
-template< S32 startArgc, typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
-struct _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F, G, H, I ) >
-{
-   typedef typename _EngineConsoleThunkType< R >::ReturnType ReturnType;
-   static const S32 NUM_ARGS = 9 + startArgc;
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( *fn )( A, B, C, D, E, F, G, H, I ), const _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H, I ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.d ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.e ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.f ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.g ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.h ) );
-      I i = ( startArgc + 8 < argc ? EngineUnmarshallData< I >()( argv[ startArgc + 8 ] ) : I( defaultArgs.i ) );
-      
-      return _EngineConsoleThunkReturnValue( fn( a, b, c, d, e, f, g, h, i ) );
-   }
-   template< typename Frame >
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( Frame::*fn )( A, B, C, D, E, F, G, H, I ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C, D, E, F, G, H, I ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.e ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.f ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.g ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.h ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.i ) );
-      I i = ( startArgc + 8 < argc ? EngineUnmarshallData< I >()( argv[ startArgc + 8 ] ) : I( defaultArgs.j ) );
-      
-      return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c, d, e, f, g, h, i ) );
-   }
-};
-
-template< S32 startArgc, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
-struct _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F, G, H, I ) >
-{
-   typedef void ReturnType;
-   static const S32 NUM_ARGS = 9 + startArgc;
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( *fn )( A, B, C, D, E, F, G, H, I ), const _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H, I ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.d ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.e ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.f ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.g ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.h ) );
-      I i = ( startArgc + 8 < argc ? EngineUnmarshallData< I >()( argv[ startArgc + 8 ] ) : I( defaultArgs.i ) );
-      
-      fn( a, b, c, d, e, f, g, h, i );
-   }
-   template< typename Frame >
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( Frame::*fn )( A, B, C, D, E, F, G, H, I ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C, D, E, F, G, H, I ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.e ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.f ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.g ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.h ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.i ) );
-      I i = ( startArgc + 8 < argc ? EngineUnmarshallData< I >()( argv[ startArgc + 8 ] ) : I( defaultArgs.j ) );
-      
-      ( frame->*fn )( a, b, c, d, e, f, g, h, i );
-   }
-};
-
-
-template< S32 startArgc, typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J >
-struct _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F, G, H, I, J ) >
-{
-   typedef typename _EngineConsoleThunkType< R >::ReturnType ReturnType;
-   static const S32 NUM_ARGS = 10 + startArgc;
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( *fn )( A, B, C, D, E, F, G, H, I, J ), const _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H, I, J ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.d ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.e ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.f ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.g ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.h ) );
-      I i = ( startArgc + 8 < argc ? EngineUnmarshallData< I >()( argv[ startArgc + 8 ] ) : I( defaultArgs.i ) );
-      J j = ( startArgc + 9 < argc ? EngineUnmarshallData< J >()( argv[ startArgc + 9 ] ) : J( defaultArgs.j ) );
-      
-      return _EngineConsoleThunkReturnValue( fn( a, b, c, d, e, f, g, h, i, j ) );
-   }
-   template< typename Frame >
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( Frame::*fn )( A, B, C, D, E, F, G, H, I, J ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C, D, E, F, G, H, I, J ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.e ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.f ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.g ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.h ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.i ) );
-      I i = ( startArgc + 8 < argc ? EngineUnmarshallData< I >()( argv[ startArgc + 8 ] ) : I( defaultArgs.j ) );
-      J j = ( startArgc + 9 < argc ? EngineUnmarshallData< J >()( argv[ startArgc + 9 ] ) : J( defaultArgs.k ) );
-      
-      return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c, d, e, f, g, h, i, j ) );
-   }
-};
-
-template< S32 startArgc, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J >
-struct _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F, G, H, I, J ) >
-{
-   typedef void ReturnType;
-   static const S32 NUM_ARGS = 10 + startArgc;
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( *fn )( A, B, C, D, E, F, G, H, I, J ), const _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H, I, J ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.d ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.e ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.f ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.g ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.h ) );
-      I i = ( startArgc + 8 < argc ? EngineUnmarshallData< I >()( argv[ startArgc + 8 ] ) : I( defaultArgs.i ) );
-      J j = ( startArgc + 9 < argc ? EngineUnmarshallData< J >()( argv[ startArgc + 9 ] ) : J( defaultArgs.j ) );
-      
-      fn( a, b, c, d, e, f, g, h, i, j );
-   }
-   template< typename Frame >
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( Frame::*fn )( A, B, C, D, E, F, G, H, I, J ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C, D, E, F, G, H, I, J ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.e ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.f ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.g ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.h ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.i ) );
-      I i = ( startArgc + 8 < argc ? EngineUnmarshallData< I >()( argv[ startArgc + 8 ] ) : I( defaultArgs.j ) );
-      J j = ( startArgc + 9 < argc ? EngineUnmarshallData< J >()( argv[ startArgc + 9 ] ) : J( defaultArgs.k ) );
-      
-      ( frame->*fn )( a, b, c, d, e, f, g, h, i, j );
-   }
-};
-
-
-template< S32 startArgc, typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K >
-struct _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F, G, H, I, J, K ) >
-{
-   typedef typename _EngineConsoleThunkType< R >::ReturnType ReturnType;
-   static const S32 NUM_ARGS = 11 + startArgc;
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( *fn )( A, B, C, D, E, F, G, H, I, J, K ), const _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H, I, J, K ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.d ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.e ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.f ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.g ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.h ) );
-      I i = ( startArgc + 8 < argc ? EngineUnmarshallData< I >()( argv[ startArgc + 8 ] ) : I( defaultArgs.i ) );
-      J j = ( startArgc + 9 < argc ? EngineUnmarshallData< J >()( argv[ startArgc + 9 ] ) : J( defaultArgs.j ) );
-      K k = ( startArgc + 10 < argc ? EngineUnmarshallData< K >()( argv[ startArgc + 10 ] ) : K( defaultArgs.k ) );
-      
-      return _EngineConsoleThunkReturnValue( fn( a, b, c, d, e, f, g, h, i, j, k ) );
-   }
-   template< typename Frame >
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( Frame::*fn )( A, B, C, D, E, F, G, H, I, J, K ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C, D, E, F, G, H, I, J, K ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.e ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.f ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.g ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.h ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.i ) );
-      I i = ( startArgc + 8 < argc ? EngineUnmarshallData< I >()( argv[ startArgc + 8 ] ) : I( defaultArgs.j ) );
-      J j = ( startArgc + 9 < argc ? EngineUnmarshallData< J >()( argv[ startArgc + 9 ] ) : J( defaultArgs.k ) );
-      K k = ( startArgc + 10 < argc ? EngineUnmarshallData< K >()( argv[ startArgc + 10 ] ) : K( defaultArgs.l ) );
-      
-      return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c, d, e, f, g, h, i, j, k ) );
-   }
-};
-
-template< S32 startArgc, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K >
-struct _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F, G, H, I, J, K ) >
-{
-   typedef void ReturnType;
-   static const S32 NUM_ARGS = 11 + startArgc;
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( *fn )( A, B, C, D, E, F, G, H, I, J, K ), const _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H, I, J, K ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.d ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.e ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.f ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.g ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.h ) );
-      I i = ( startArgc + 8 < argc ? EngineUnmarshallData< I >()( argv[ startArgc + 8 ] ) : I( defaultArgs.i ) );
-      J j = ( startArgc + 9 < argc ? EngineUnmarshallData< J >()( argv[ startArgc + 9 ] ) : J( defaultArgs.j ) );
-      K k = ( startArgc + 10 < argc ? EngineUnmarshallData< K >()( argv[ startArgc + 10 ] ) : K( defaultArgs.k ) );
-      
-      fn( a, b, c, d, e, f, g, h, i, j, k );
-   }
-   template< typename Frame >
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( Frame::*fn )( A, B, C, D, E, F, G, H, I, J, K ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C, D, E, F, G, H, I, J, K ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.e ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.f ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.g ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.h ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.i ) );
-      I i = ( startArgc + 8 < argc ? EngineUnmarshallData< I >()( argv[ startArgc + 8 ] ) : I( defaultArgs.j ) );
-      J j = ( startArgc + 9 < argc ? EngineUnmarshallData< J >()( argv[ startArgc + 9 ] ) : J( defaultArgs.k ) );
-      K k = ( startArgc + 10 < argc ? EngineUnmarshallData< K >()( argv[ startArgc + 10 ] ) : K( defaultArgs.l ) );
-      
-      ( frame->*fn )( a, b, c, d, e, f, g, h, i, j, k );
-   }
-};
-
-
-template< S32 startArgc, typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L >
-struct _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F, G, H, I, J, K, L ) >
-{
-   typedef typename _EngineConsoleThunkType< R >::ReturnType ReturnType;
-   static const S32 NUM_ARGS = 12 + startArgc;
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( *fn )( A, B, C, D, E, F, G, H, I, J, K, L ), const _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H, I, J, K, L ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.d ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.e ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.f ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.g ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.h ) );
-      I i = ( startArgc + 8 < argc ? EngineUnmarshallData< I >()( argv[ startArgc + 8 ] ) : I( defaultArgs.i ) );
-      J j = ( startArgc + 9 < argc ? EngineUnmarshallData< J >()( argv[ startArgc + 9 ] ) : J( defaultArgs.j ) );
-      K k = ( startArgc + 10 < argc ? EngineUnmarshallData< K >()( argv[ startArgc + 10 ] ) : K( defaultArgs.k ) );
-      L l = ( startArgc + 11 < argc ? EngineUnmarshallData< L >()( argv[ startArgc + 11 ] ) : L( defaultArgs.l ) );
-      
-      return _EngineConsoleThunkReturnValue( fn( a, b, c, d, e, f, g, h, i, j, k, l ) );
-   }
-   template< typename Frame >
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( Frame::*fn )( A, B, C, D, E, F, G, H, I, J, K, L ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C, D, E, F, G, H, I, J, K, L ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.e ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.f ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.g ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.h ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.i ) );
-      I i = ( startArgc + 8 < argc ? EngineUnmarshallData< I >()( argv[ startArgc + 8 ] ) : I( defaultArgs.j ) );
-      J j = ( startArgc + 9 < argc ? EngineUnmarshallData< J >()( argv[ startArgc + 9 ] ) : J( defaultArgs.k ) );
-      K k = ( startArgc + 10 < argc ? EngineUnmarshallData< K >()( argv[ startArgc + 10 ] ) : K( defaultArgs.l ) );
-      L l = ( startArgc + 11 < argc ? EngineUnmarshallData< L >()( argv[ startArgc + 11 ] ) : L( defaultArgs.l ) );
-      
-      return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c, d, e, f, g, h, i, j, k, l ) );
-   }
-};
-
-template< S32 startArgc, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L >
-struct _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F, G, H, I, J, K, L ) >
-{
-   typedef void ReturnType;
-   static const S32 NUM_ARGS = 12 + startArgc;
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( *fn )( A, B, C, D, E, F, G, H, I, J, K, L ), const _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H, I, J, K, L ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.a ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.b ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.c ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.d ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.e ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.f ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.g ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.h ) );
-      I i = ( startArgc + 8 < argc ? EngineUnmarshallData< I >()( argv[ startArgc + 8 ] ) : I( defaultArgs.i ) );
-      J j = ( startArgc + 9 < argc ? EngineUnmarshallData< J >()( argv[ startArgc + 9 ] ) : J( defaultArgs.j ) );
-      K k = ( startArgc + 10 < argc ? EngineUnmarshallData< K >()( argv[ startArgc + 10 ] ) : K( defaultArgs.k ) );
-      L l = ( startArgc + 11 < argc ? EngineUnmarshallData< L >()( argv[ startArgc + 11 ] ) : L( defaultArgs.l ) );
-      
-      fn( a, b, c, d, e, f, g, h, i, j, k, l );
-   }
-   template< typename Frame >
-   static void thunk( S32 argc, ConsoleValueRef *argv, void ( Frame::*fn )( A, B, C, D, E, F, G, H, I, J, K, L ) const, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, A, B, C, D, E, F, G, H, I, J, K, L ) >& defaultArgs )
-   {
-      A a = ( startArgc + 0 < argc ? EngineUnmarshallData< A >()( argv[ startArgc + 0 ] ) : A( defaultArgs.b ) );
-      B b = ( startArgc + 1 < argc ? EngineUnmarshallData< B >()( argv[ startArgc + 1 ] ) : B( defaultArgs.c ) );
-      C c = ( startArgc + 2 < argc ? EngineUnmarshallData< C >()( argv[ startArgc + 2 ] ) : C( defaultArgs.d ) );
-      D d = ( startArgc + 3 < argc ? EngineUnmarshallData< D >()( argv[ startArgc + 3 ] ) : D( defaultArgs.e ) );
-      E e = ( startArgc + 4 < argc ? EngineUnmarshallData< E >()( argv[ startArgc + 4 ] ) : E( defaultArgs.f ) );
-      F f = ( startArgc + 5 < argc ? EngineUnmarshallData< F >()( argv[ startArgc + 5 ] ) : F( defaultArgs.g ) );
-      G g = ( startArgc + 6 < argc ? EngineUnmarshallData< G >()( argv[ startArgc + 6 ] ) : G( defaultArgs.h ) );
-      H h = ( startArgc + 7 < argc ? EngineUnmarshallData< H >()( argv[ startArgc + 7 ] ) : H( defaultArgs.i ) );
-      I i = ( startArgc + 8 < argc ? EngineUnmarshallData< I >()( argv[ startArgc + 8 ] ) : I( defaultArgs.j ) );
-      J j = ( startArgc + 9 < argc ? EngineUnmarshallData< J >()( argv[ startArgc + 9 ] ) : J( defaultArgs.k ) );
-      K k = ( startArgc + 10 < argc ? EngineUnmarshallData< K >()( argv[ startArgc + 10 ] ) : K( defaultArgs.l ) );
-      L l = ( startArgc + 11 < argc ? EngineUnmarshallData< L >()( argv[ startArgc + 11 ] ) : L( defaultArgs.l ) );
-      
-      ( frame->*fn )( a, b, c, d, e, f, g, h, i, j, k, l );
-   }
-};
-
-
-
-/// @}
-
-/// @name API Definition Macros
-///
-/// The macros in this group allow to create engine API functions that work both with the
-/// legacy console system as well as with the new engine export system.  As such, they only
-/// support those function features that are available in both systems.  This means that for
-/// console-style variadic functions, the ConsoleXXX must be used and that for overloaded
-/// and/or C-style variadic functions as well as for placing functions in export scopes,
-/// DEFINE_CALLIN must be used directly.
-///
-/// When the console system is removed, the console thunking functionality will be removed
-/// from these macros but otherwise they will remain unchanged and in place.
-///
-/// @{
-
-
-// Helpers to implement initialization checks.  Pulled out into separate macros so this can be deactivated easily.
-// Especially important for the initialize() function itself.
-
-#define _CHECK_ENGINE_INITIALIZED_IMPL( fnName, returnType )                                                                     \
-      if( !engineAPI::gIsInitialized )                                                                                           \
-      {                                                                                                                          \
-         Con::errorf( "EngineAPI: Engine not initialized when calling " #fnName );                                               \
-         return EngineTypeTraits< returnType >::ReturnValue( EngineTypeTraits< returnType >::ReturnValueType() );                \
-      }
-
-#define _CHECK_ENGINE_INITIALIZED( fnName, returnType ) _CHECK_ENGINE_INITIALIZED_IMPL( fnName, returnType )
-
-
-/// Define a call-in point for calling into the engine.
-///
-/// @param name The name of the function as it should be seen by the control layer.
-/// @param returnType The value type returned to the control layer.
-/// @param args The argument list as it would appear on the function definition
-/// @param defaultArgs The list of default argument values.
-/// @param usage The usage doc string for the engine API reference.
-///
-/// @code
-/// DefineEngineFunction( myFunction, int, ( float f, const String& s ), ( "value for s" ), "This is my function." )
-/// {
-///    return int( f ) + dAtoi( s );
-/// }
-/// @endcode
-#define DefineEngineFunction( name, returnType, args, defaultArgs, usage )                                                       \
-   static inline returnType _fn ## name ## impl args;                                                                            \
-   TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## name                                                         \
-      ( _EngineFunctionTrampoline< returnType args >::Args a )                                                                   \
-   {                                                                                                                             \
-      _CHECK_ENGINE_INITIALIZED( name, returnType );                                                                             \
-      return EngineTypeTraits< returnType >::ReturnValue(                                                                        \
-         _EngineFunctionTrampoline< returnType args >::jmp( _fn ## name ## impl, a )                                             \
-      );                                                                                                                         \
-   }                                                                                                                             \
-   static _EngineFunctionDefaultArguments< void args > _fn ## name ## DefaultArgs defaultArgs;                                   \
-   static EngineFunctionInfo _fn ## name ## FunctionInfo(                                                                        \
-      #name,                                                                                                                     \
-      &_SCOPE<>()(),                                                                                                             \
-      usage,                                                                                                                     \
-      #returnType " " #name #args,                                                                                               \
-      "fn" #name,                                                                                                                \
-      TYPE< returnType args >(),                                                                                                 \
-      &_fn ## name ## DefaultArgs,                                                                                               \
-      ( void* ) &fn ## name,                                                                                                     \
-      0                                                                                                                          \
-   );                                                                                                                            \
-   static _EngineConsoleThunkType< returnType >::ReturnType _ ## name ## caster( SimObject*, S32 argc, ConsoleValueRef *argv )       \
-   {                                                                                                                             \
-      return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 1, returnType args >::thunk(                \
-         argc, argv, &_fn ## name ## impl, _fn ## name ## DefaultArgs                                                            \
-      ) );                                                                                                                       \
-   }                                                                                                                             \
-   static ConsoleFunctionHeader _ ## name ## header                                                                              \
-      ( #returnType, #args, #defaultArgs );                                                                                      \
-   static ConsoleConstructor                                                                                                     \
-      _ ## name ## obj( NULL, #name, _EngineConsoleThunkType< returnType >::CallbackType( _ ## name ## caster ), usage,          \
-         _EngineConsoleThunk< 1, returnType args >::NUM_ARGS - _EngineConsoleThunkCountArgs() defaultArgs,                       \
-         _EngineConsoleThunk< 1, returnType args >::NUM_ARGS,                                                                    \
-         false, &_ ## name ## header                                                                                             \
-      );                                                                                                                         \
-   static inline returnType _fn ## name ## impl args
-   
-   
-// The next thing is a bit tricky.  DefineEngineMethod allows to make the 'object' (=this) argument to the function
-// implicit which presents quite an obstacle for the macro internals as the engine export system requires the
-// name of a DLL symbol that represents an extern "C" function with an explicit first object pointer argument.
-//
-// Even if we ignored the fact that we don't have a guarantee how the various C++ compilers implement implicit 'this' arguments,
-// we could still not just use a C++ method for this as then we would have to get past the C++ compiler's mangling to
-// get to the function symbol name (let alone the fact that typing this method correctly would be tricky).
-//
-// So, the trick employed here is to package all but the implicit 'this' argument in a structure and then define an
-// extern "C" function that takes the object pointer as a first argument and the struct type as the second argument.
-// This will result in a function with an identical stack call frame layout to the function we want.
-//
-// Unfortunately, that still requires that function to chain on to the real user-defined function.  To do this
-// cleanly and portably, _EngineMethodTrampoline is used to unpack and jump the call from extern "C" into C++ space.
-// In optimized builds, the compiler should be smart enough to pretty much optimize all our trickery here away.
-
-#define _DefineMethodTrampoline( className, name, returnType, args ) \
-   TORQUE_API EngineTypeTraits< returnType >::ReturnValueType \
-      fn ## className ## _ ## name ( className* object, _EngineMethodTrampoline< _ ## className ## name ## frame, returnType args >::Args a )   \
-   {                                                                                                                                            \
-      _CHECK_ENGINE_INITIALIZED( className::name, returnType );                                                                                 \
-      return EngineTypeTraits< returnType >::ReturnValue(                                                                                       \
-         _EngineMethodTrampoline< _ ## className ## name ## frame, returnType args >::jmp( object, a )                                          \
-      );                                                                                                                                        \
-   }
-
-
-/// Define a call-in point for calling a method on an engine object.
-///
-/// @param name The name of the C++ class.
-/// @param name The name of the method as it should be seen by the control layer.
-/// @param returnType The value type returned to the control layer.
-/// @param args The argument list as it would appear on the function definition
-/// @param defaultArgs The list of default argument values.
-/// @param usage The usage doc string for the engine API reference.
-///
-/// @code
-/// DefineEngineMethod( MyClass, myMethod, int, ( float f, const String& s ), ( "value for s" ), "This is my method." )
-/// {
-///    return object->someMethod( f, s );
-/// }
-/// @endcode
-#define DefineEngineMethod( className, name, returnType, args, defaultArgs, usage )                                                             \
-   struct _ ## className ## name ## frame                                                                                                       \
-   {                                                                                                                                            \
-      typedef className ObjectType;                                                                                                             \
-      className* object;                                                                                                                        \
-      inline returnType _exec args const;                                                                                                       \
-   };                                                                                                                                           \
-   _DefineMethodTrampoline( className, name, returnType, args );                                                                                \
-   static _EngineFunctionDefaultArguments< _EngineMethodTrampoline< _ ## className ## name ## frame, void args >::FunctionType >                \
-      _fn ## className ## name ## DefaultArgs defaultArgs;                                                                                      \
-   static EngineFunctionInfo _fn ## className ## name ## FunctionInfo(                                                                          \
-      #name,                                                                                                                                    \
-      &_SCOPE< className >()(),                                                                                                                 \
-      usage,                                                                                                                                    \
-      "virtual " #returnType " " #name #args,                                                                                                   \
-      "fn" #className "_" #name,                                                                                                                \
-      TYPE< _EngineMethodTrampoline< _ ## className ## name ## frame, returnType args >::FunctionType >(),                                      \
-      &_fn ## className ## name ## DefaultArgs,                                                                                                 \
-      ( void* ) &fn ## className ## _ ## name,                                                                                                  \
-      0                                                                                                                                         \
-   );                                                                                                                                           \
-   static _EngineConsoleThunkType< returnType >::ReturnType _ ## className ## name ## caster( SimObject* object, S32 argc, ConsoleValueRef *argv )  \
-   {                                                                                                                                            \
-      _ ## className ## name ## frame frame;                                                                                                    \
-      frame.object = static_cast< className* >( object );                                                                                       \
-      return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 2, returnType args >::thunk(                               \
-         argc, argv, &_ ## className ## name ## frame::_exec, &frame, _fn ## className ## name ## DefaultArgs                                   \
-      ) );                                                                                                                                      \
-   }                                                                                                                                            \
-   static ConsoleFunctionHeader _ ## className ## name ## header                                                                                \
-      ( #returnType, #args, #defaultArgs );                                                                                                     \
-   static ConsoleConstructor                                                                                                                    \
-      className ## name ## obj( #className, #name,                                                                                              \
-         _EngineConsoleThunkType< returnType >::CallbackType( _ ## className ## name ## caster ), usage,                                        \
-         _EngineConsoleThunk< 2, returnType args >::NUM_ARGS - _EngineConsoleThunkCountArgs() defaultArgs,                                      \
-         _EngineConsoleThunk< 2, returnType args >::NUM_ARGS,                                                                                   \
-         false, &_ ## className ## name ## header                                                                                               \
-      );                                                                                                                                        \
-   returnType _ ## className ## name ## frame::_exec args const
-   
-   
-/// Define a call-in point for calling into the engine.  Unlike with DefineEngineFunction, the statically
-/// callable function will be confined to the namespace of the given class.
-///
-/// @param name The name of the C++ class (or a registered export scope).
-/// @param name The name of the method as it should be seen by the control layer.
-/// @param returnType The value type returned to the control layer.
-/// @param args The argument list as it would appear on the function definition
-/// @param defaultArgs The list of default argument values.
-/// @param usage The usage doc string for the engine API reference.
-///
-/// @code
-/// DefineEngineStaticMethod( MyClass, myMethod, int, ( float f, string s ), ( "value for s" ), "This is my method." )
-/// {
-/// }
-/// @endcode
-#define DefineEngineStaticMethod( className, name, returnType, args, defaultArgs, usage )                                              \
-   static inline returnType _fn ## className ## name ## impl args;                                                                     \
-   TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## className ## _ ## name                                             \
-      ( _EngineFunctionTrampoline< returnType args >::Args a )                                                                         \
-   {                                                                                                                                   \
-      _CHECK_ENGINE_INITIALIZED( className::name, returnType );                                                                        \
-      return EngineTypeTraits< returnType >::ReturnValue(                                                                              \
-         _EngineFunctionTrampoline< returnType args >::jmp( _fn ## className ## name ## impl, a )                                      \
-      );                                                                                                                               \
-   }                                                                                                                                   \
-   static _EngineFunctionDefaultArguments< void args > _fn ## className ## name ## DefaultArgs defaultArgs;                            \
-   static EngineFunctionInfo _fn ## name ## FunctionInfo(                                                                              \
-      #name,                                                                                                                           \
-      &_SCOPE< className >()(),                                                                                                        \
-      usage,                                                                                                                           \
-      #returnType " " #name #args,                                                                                                     \
-      "fn" #className "_" #name,                                                                                                       \
-      TYPE< returnType args >(),                                                                                                       \
-      &_fn ## className ## name ## DefaultArgs,                                                                                        \
-      ( void* ) &fn ## className ## _ ## name,                                                                                         \
-      0                                                                                                                                \
-   );                                                                                                                                  \
-   static _EngineConsoleThunkType< returnType >::ReturnType _ ## className ## name ## caster( SimObject*, S32 argc, ConsoleValueRef *argv )\
-   {                                                                                                                                   \
-      return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 1, returnType args >::thunk(                      \
-         argc, argv, &_fn ## className ## name ## impl, _fn ## className ## name ## DefaultArgs                                        \
-      ) );                                                                                                                             \
-   }                                                                                                                                   \
-   static ConsoleFunctionHeader _ ## className ## name ## header                                                                       \
-      ( #returnType, #args, #defaultArgs, true );                                                                                      \
-   static ConsoleConstructor                                                                                                           \
-      _ ## className ## name ## obj( #className, #name, _EngineConsoleThunkType< returnType >::CallbackType( _ ## className ## name ## caster ), usage, \
-         _EngineConsoleThunk< 1, returnType args >::NUM_ARGS - _EngineConsoleThunkCountArgs() defaultArgs,                             \
-         _EngineConsoleThunk< 1, returnType args >::NUM_ARGS,                                                                          \
-         false, &_ ## className ## name ## header                                                                                      \
-      );                                                                                                                               \
-   static inline returnType _fn ## className ## name ## impl args
-
-
-// Convenience macros to allow defining functions that use the new marshalling features
-// while being only visible in the console interop.  When we drop the console system,
-// these macros can be removed and all definitions that make use of them can be removed
-// as well.
-#define DefineConsoleFunction( name, returnType, args, defaultArgs, usage )                                                      \
-   static inline returnType _fn ## name ## impl args;                                                                            \
-   static _EngineFunctionDefaultArguments< void args > _fn ## name ## DefaultArgs defaultArgs;                                   \
-   static _EngineConsoleThunkType< returnType >::ReturnType _ ## name ## caster( SimObject*, S32 argc, ConsoleValueRef *argv )       \
-   {                                                                                                                             \
-      return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 1, returnType args >::thunk(                \
-         argc, argv, &_fn ## name ## impl, _fn ## name ## DefaultArgs                                                            \
-      ) );                                                                                                                       \
-   }                                                                                                                             \
-   static ConsoleFunctionHeader _ ## name ## header                                                                              \
-      ( #returnType, #args, #defaultArgs );                                                                                      \
-   static ConsoleConstructor                                                                                                     \
-      _ ## name ## obj( NULL, #name, _EngineConsoleThunkType< returnType >::CallbackType( _ ## name ## caster ), usage,          \
-         _EngineConsoleThunk< 1, returnType args >::NUM_ARGS - _EngineConsoleThunkCountArgs() defaultArgs,                       \
-         _EngineConsoleThunk< 1, returnType args >::NUM_ARGS,                                                                    \
-         false, &_ ## name ## header                                                                                             \
-      );                                                                                                                         \
-   static inline returnType _fn ## name ## impl args
-
-#define DefineConsoleMethod( className, name, returnType, args, defaultArgs, usage )                                                            \
-   struct _ ## className ## name ## frame                                                                                                       \
-   {                                                                                                                                            \
-      typedef className ObjectType;                                                                                                             \
-      className* object;                                                                                                                        \
-      inline returnType _exec args const;                                                                                                       \
-   };                                                                                                                                           \
-   static _EngineFunctionDefaultArguments< _EngineMethodTrampoline< _ ## className ## name ## frame, void args >::FunctionType >                \
-      _fn ## className ## name ## DefaultArgs defaultArgs;                                                                                      \
-   static _EngineConsoleThunkType< returnType >::ReturnType _ ## className ## name ## caster( SimObject* object, S32 argc, ConsoleValueRef *argv )  \
-   {                                                                                                                                            \
-      _ ## className ## name ## frame frame;                                                                                                    \
-      frame.object = static_cast< className* >( object );                                                                                       \
-      return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 2, returnType args >::thunk(                               \
-         argc, argv, &_ ## className ## name ## frame::_exec, &frame, _fn ## className ## name ## DefaultArgs                                   \
-      ) );                                                                                                                                      \
-   }                                                                                                                                            \
-   static ConsoleFunctionHeader _ ## className ## name ## header                                                                                \
-      ( #returnType, #args, #defaultArgs );                                                                                                     \
-   static ConsoleConstructor                                                                                                                    \
-      className ## name ## obj( #className, #name,                                                                                              \
-         _EngineConsoleThunkType< returnType >::CallbackType( _ ## className ## name ## caster ), usage,                                        \
-         _EngineConsoleThunk< 2, returnType args >::NUM_ARGS - _EngineConsoleThunkCountArgs() defaultArgs,                                      \
-         _EngineConsoleThunk< 2, returnType args >::NUM_ARGS,                                                                                   \
-         false, &_ ## className ## name ## header                                                                                               \
-      );                                                                                                                                        \
-   returnType _ ## className ## name ## frame::_exec args const
-
-#define DefineConsoleStaticMethod( className, name, returnType, args, defaultArgs, usage )                                             \
-   static inline returnType _fn ## className ## name ## impl args;                                                                     \
-   static _EngineFunctionDefaultArguments< void args > _fn ## className ## name ## DefaultArgs defaultArgs;                            \
-   static _EngineConsoleThunkType< returnType >::ReturnType _ ## className ## name ## caster( SimObject*, S32 argc, ConsoleValueRef *argv )\
-   {                                                                                                                                   \
-      return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 1, returnType args >::thunk(                      \
-         argc, argv, &_fn ## className ## name ## impl, _fn ## className ## name ## DefaultArgs                                        \
-      ) );                                                                                                                             \
-   }                                                                                                                                   \
-   static ConsoleFunctionHeader _ ## className ## name ## header                                                                       \
-      ( #returnType, #args, #defaultArgs, true );                                                                                      \
-   static ConsoleConstructor                                                                                                           \
-      _ ## className ## name ## obj( #className, #name, _EngineConsoleThunkType< returnType >::CallbackType( _ ## className ## name ## caster ), usage, \
-         _EngineConsoleThunk< 1, returnType args >::NUM_ARGS - _EngineConsoleThunkCountArgs() defaultArgs,                             \
-         _EngineConsoleThunk< 1, returnType args >::NUM_ARGS,                                                                          \
-         false, &_ ## className ## name ## header                                                                                      \
-      );                                                                                                                               \
-   static inline returnType _fn ## className ## name ## impl args
-
-
-// The following three macros are only temporary.  They allow to define engineAPI functions using the framework
-// here in this file while being visible only in the new API.  When the console interop is removed, these macros
-// can be removed and all their uses be replaced with their corresponding versions that now still include support
-// for the console (e.g. DefineNewEngineFunction should become DefineEngineFunction).
-#define DefineNewEngineFunction( name, returnType, args, defaultArgs, usage )                                                    \
-   static inline returnType _fn ## name ## impl args;                                                                            \
-   TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## name                                                         \
-      ( _EngineFunctionTrampoline< returnType args >::Args a )                                                                   \
-   {                                                                                                                             \
-      _CHECK_ENGINE_INITIALIZED( name, returnType );                                                                             \
-      return EngineTypeTraits< returnType >::ReturnValue(                                                                        \
-         _EngineFunctionTrampoline< returnType args >::jmp( _fn ## name ## impl, a )                                             \
-      );                                                                                                                         \
-   }                                                                                                                             \
-   static _EngineFunctionDefaultArguments< void args > _fn ## name ## DefaultArgs defaultArgs;                                   \
-   static EngineFunctionInfo _fn ## name ## FunctionInfo(                                                                        \
-      #name,                                                                                                                     \
-      &_SCOPE<>()(),                                                                                                             \
-      usage,                                                                                                                     \
-      #returnType " " #name #args,                                                                                               \
-      "fn" #name,                                                                                                                \
-      TYPE< returnType args >(),                                                                                                 \
-      &_fn ## name ## DefaultArgs,                                                                                               \
-      ( void* ) &fn ## name,                                                                                                     \
-      0                                                                                                                          \
-   );                                                                                                                            \
-   static inline returnType _fn ## name ## impl args
-
-#define DefineNewEngineMethod( className, name, returnType, args, defaultArgs, usage )                                                          \
-   struct _ ## className ## name ## frame                                                                                                       \
-   {                                                                                                                                            \
-      typedef className ObjectType;                                                                                                             \
-      className* object;                                                                                                                        \
-      inline returnType _exec args const;                                                                                                       \
-   };                                                                                                                                           \
-   _DefineMethodTrampoline( className, name, returnType, args );                                                                                \
-   static _EngineFunctionDefaultArguments< _EngineMethodTrampoline< _ ## className ## name ## frame, void args >::FunctionType >                \
-      _fn ## className ## name ## DefaultArgs defaultArgs;                                                                                      \
-   static EngineFunctionInfo _fn ## className ## name ## FunctionInfo(                                                                          \
-      #name,                                                                                                                                    \
-      &_SCOPE< className >()(),                                                                                                                 \
-      usage,                                                                                                                                    \
-      "virtual " #returnType " " #name #args,                                                                                                   \
-      "fn" #className "_" #name,                                                                                                                \
-      TYPE< _EngineMethodTrampoline< _ ## className ## name ## frame, returnType args >::FunctionType >(),                                      \
-      &_fn ## className ## name ## DefaultArgs,                                                                                                 \
-      ( void* ) &fn ## className ## _ ## name,                                                                                                  \
-      0                                                                                                                                         \
-   );                                                                                                                                           \
-   returnType _ ## className ## name ## frame::_exec args const
-
-#define DefineNewEngineStaticMethod( className, name, returnType, args, defaultArgs, usage )                                           \
-   static inline returnType _fn ## className ## name ## impl args;                                                                     \
-   TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## className ## _ ## name                                             \
-      ( _EngineFunctionTrampoline< returnType args >::Args a )                                                                         \
-   {                                                                                                                                   \
-      _CHECK_ENGINE_INITIALIZED( className::name, returnType );                                                                        \
-      return EngineTypeTraits< returnType >::ReturnValue(                                                                              \
-         _EngineFunctionTrampoline< returnType args >::jmp( _fn ## className ## name ## impl, a )                                      \
-      );                                                                                                                               \
-   }                                                                                                                                   \
-   static _EngineFunctionDefaultArguments< void args > _fn ## className ## name ## DefaultArgs defaultArgs;                            \
-   static EngineFunctionInfo _fn ## name ## FunctionInfo(                                                                              \
-      #name,                                                                                                                           \
-      &_SCOPE< className >()(),                                                                                                        \
-      usage,                                                                                                                           \
-      #returnType " " #name #args,                                                                                                     \
-      "fn" #className "_" #name,                                                                                                       \
-      TYPE< returnType args >(),                                                                                                       \
-      &_fn ## className ## name ## DefaultArgs,                                                                                        \
-      ( void* ) &fn ## className ## _ ## name,                                                                                         \
-      0                                                                                                                                \
-   );                                                                                                                                  \
-   static inline returnType _fn ## className ## name ## impl args
-
-/// @}
-
-
-//=============================================================================
-//    Callbacks.
-//=============================================================================
-
-/// Matching implement for DECLARE_CALLBACK.
-///
-///
-/// @warn With the new interop system, method-style callbacks <em>must not</em> be triggered on object
-///   that are being created!  This is because the control layer will likely not yet have a fully valid wrapper
-///   object in place for the EngineObject under construction.
-#define IMPLEMENT_CALLBACK( class, name, returnType, args, argNames, usageString )                                                           \
-   struct _ ## class ## name ## frame { typedef class ObjectType; };                                                                         \
-   TORQUE_API _EngineMethodTrampoline< _ ## class ## name ## frame, returnType args >::FunctionType* cb ## class ## _ ## name;               \
-   TORQUE_API void set_cb ## class ## _ ## name(                                                                                             \
-      _EngineMethodTrampoline< _ ## class ## name ## frame, returnType args >::FunctionType fn )                                             \
-      { cb ## class ## _ ## name = fn; }                                                                                                     \
-   _EngineMethodTrampoline< _ ## class ## name ## frame, returnType args >::FunctionType* cb ## class ## _ ## name;                          \
-   namespace {                                                                                                                               \
-      ::EngineFunctionInfo _cb ## class ## name(                                                                                             \
-         #name,                                                                                                                              \
-         &::_SCOPE< class >()(),                                                                                                             \
-         usageString,                                                                                                                        \
-         "virtual " #returnType " " #name #args,                                                                                             \
-         "cb" #class "_" #name,                                                                                                              \
-         ::TYPE< _EngineMethodTrampoline< _ ## class ## name ## frame, returnType args >::FunctionType >(),                                  \
-         NULL,                                                                                                                               \
-         ( void* ) &cb ## class ## _ ## name,                                                                                                \
-         EngineFunctionCallout                                                                                                               \
-      );                                                                                                                                     \
-   }                                                                                                                                         \
-   returnType class::name ## _callback args                                                                                                  \
-   {                                                                                                                                         \
-      if( cb ## class ## _ ## name ) {                                                                                                       \
-         _EngineCallbackHelper cbh( this, reinterpret_cast< const void* >( cb ## class ## _ ## name ) );                                     \
-         return returnType( cbh.call< returnType > argNames );                                                                               \
-      }                                                                                                                                      \
-      if( engineAPI::gUseConsoleInterop )                                                                                                    \
-      {                                                                                                                                      \
-         static StringTableEntry sName = StringTable->insert( #name );                                                                       \
-         _EngineConsoleCallbackHelper cbh( sName, this );                                                                                    \
-         return returnType( cbh.call< returnType > argNames );                                                                               \
-      }                                                                                                                                      \
-      return returnType();                                                                                                                   \
-   }                                                                                                                                         \
-   namespace {                                                                                                                               \
-      ConsoleFunctionHeader _ ## class ## name ## header(                                                                                    \
-         #returnType, #args, "" );                                                                                                           \
-      ConsoleConstructor _ ## class ## name ## obj( #class, #name, usageString, &_ ## class ## name ## header );                             \
-   }
-
-
-/// Used to define global callbacks not associated with 
-/// any particular class or namespace.
-#define IMPLEMENT_GLOBAL_CALLBACK( name, returnType, args, argNames, usageString )                                                           \
-   DEFINE_CALLOUT( cb ## name, name,, returnType, args, 0, usageString );                                                                    \
-   returnType name ## _callback args                                                                                                         \
-   {                                                                                                                                         \
-      if( cb ## name )                                                                                                                       \
-         return returnType( cb ## name argNames );                                                                                           \
-      if( engineAPI::gUseConsoleInterop )                                                                                                    \
-      {                                                                                                                                      \
-         static StringTableEntry sName = StringTable->insert( #name );                                                                       \
-         _EngineConsoleCallbackHelper cbh( sName, NULL );                                                                                    \
-         return returnType( cbh.call< returnType > argNames );                                                                               \
-      }                                                                                                                                      \
-      return returnType();                                                                                                                   \
-   }                                                                                                                                         \
-   namespace {                                                                                                                               \
-      ConsoleFunctionHeader _ ## name ## header(                                                                                             \
-         #returnType, #args, "" );                                                                                                           \
-      ConsoleConstructor _ ## name ## obj( NULL, #name, usageString, &_ ## name ## header );                                                 \
-   }
-   
-   
-// Again, temporary macros to allow splicing the API while we still have the console interop around.
-
-#define IMPLEMENT_CONSOLE_CALLBACK( class, name, returnType, args, argNames, usageString )                                                   \
-   returnType class::name ## _callback args                                                                                                  \
-   {                                                                                                                                         \
-      if( engineAPI::gUseConsoleInterop )                                                                                                    \
-      {                                                                                                                                      \
-         static StringTableEntry sName = StringTable->insert( #name );                                                                       \
-         _EngineConsoleCallbackHelper cbh( sName, this );                                                                                    \
-         return returnType( cbh.call< returnType > argNames );                                                                               \
-      }                                                                                                                                      \
-      return returnType();                                                                                                                   \
-   }                                                                                                                                         \
-   namespace {                                                                                                                               \
-      ConsoleFunctionHeader _ ## class ## name ## header(                                                                                    \
-         #returnType, #args, "" );                                                                                                           \
-      ConsoleConstructor _ ## class ## name ## obj( #class, #name, usageString, &_ ## class ## name ## header );                             \
-   }
-   
-#define IMPLEMENT_NEW_CALLBACK( class, name, returnType, args, argNames, usageString )                                                       \
-   struct _ ## class ## name ## frame { typedef class ObjectType; };                                                                         \
-   TORQUE_API _EngineMethodTrampoline< _ ## class ## name ## frame, returnType args >::FunctionType* cb ## class ## _ ## name;               \
-   TORQUE_API void set_cb ## class ## _ ## name(                                                                                             \
-      _EngineMethodTrampoline< _ ## class ## name ## frame, returnType args >::FunctionType fn )                                             \
-      { cb ## class ## _ ## name = fn; }                                                                                                     \
-   _EngineMethodTrampoline< _ ## class ## name ## frame, returnType args >::FunctionType* cb ## class ## _ ## name;                          \
-   namespace {                                                                                                                               \
-      ::EngineFunctionInfo _cb ## class ## name(                                                                                             \
-         #name,                                                                                                                              \
-         &::_SCOPE< class >()(),                                                                                                             \
-         usageString,                                                                                                                        \
-         "virtual " #returnType " " #name #args,                                                                                             \
-         "cb" #class "_" #name,                                                                                                              \
-         ::TYPE< _EngineMethodTrampoline< _ ## class ## name ## frame, returnType args >::FunctionType >(),                                  \
-         NULL,                                                                                                                               \
-         &cb ## class ## _ ## name,                                                                                                          \
-         EngineFunctionCallout                                                                                                               \
-      );                                                                                                                                     \
-   }                                                                                                                                         \
-   returnType class::name ## _callback args                                                                                                  \
-   {                                                                                                                                         \
-      if( cb ## class ## _ ## name ) {                                                                                                       \
-         _EngineCallbackHelper cbh( this, reinterpret_cast< const void* >( cb ## class ## _ ## name ) );                                     \
-         return returnType( cbh.call< returnType > argNames );                                                                               \
-      }                                                                                                                                      \
-      return returnType();                                                                                                                   \
-   }
-
-
-
-
-// Internal helper class for doing call-outs in the new interop.
-struct _EngineCallbackHelper
-{
-   protected:
-    
-      EngineObject* mThis;
-      const void* mFn;
-            
-   public:
-
-      _EngineCallbackHelper( EngineObject* pThis, const void* fn )
-         : mThis( pThis ),
-           mFn( fn ) {}
-      
-      template< typename R >
-      R call() const
-      {
-         typedef R( FunctionType )( EngineObject* );
-         return R( reinterpret_cast< FunctionType* >( const_cast<void*>(mFn) )( mThis ) );
-      }
-
-      
-      template< typename R, typename A >
-      R call( A a ) const
-      {
-         typedef R( FunctionType )( EngineObject*, A );
-         return R( reinterpret_cast< FunctionType* >( const_cast<void*>(mFn) )( mThis, a ) );
-      }
-      
-      template< typename R, typename A, typename B >
-      R call( A a, B b ) const
-      {
-         typedef R( FunctionType )( EngineObject*, A, B );
-         return R( reinterpret_cast< FunctionType* >( const_cast<void*>(mFn) )( mThis, a, b ) );
-      }
-      
-      template< typename R, typename A, typename B, typename C >
-      R call( A a, B b, C c ) const
-      {
-         typedef R( FunctionType )( EngineObject*, A, B, C );
-         return R( reinterpret_cast< FunctionType* >( const_cast<void*>(mFn) )( mThis, a, b, c ) );
-      }
-      
-      template< typename R, typename A, typename B, typename C, typename D >
-      R call( A a, B b, C c, D d ) const
-      {
-         typedef R( FunctionType )( EngineObject*, A, B, C, D );
-         return R( reinterpret_cast< FunctionType* >( const_cast<void*>(mFn) )( mThis, a, b, c, d ) );
-      }
-      
-      template< typename R, typename A, typename B, typename C, typename D, typename E >
-      R call( A a, B b, C c, D d, E e ) const
-      {
-         typedef R( FunctionType )( EngineObject*, A, B, C, D, E );
-         return R( reinterpret_cast< FunctionType* >( const_cast<void*>(mFn) )( mThis, a, b, c, d, e ) );
-      }
-      
-      template< typename R, typename A, typename B, typename C, typename D, typename E, typename F >
-      R call( A a, B b, C c, D d, E e, F f ) const
-      {
-         typedef R( FunctionType )( EngineObject*, A, B, C, D, E, F );
-         return R( reinterpret_cast< FunctionType* >( const_cast<void*>(mFn) )( mThis, a, b, c, d, e, f ) );
-      }
-      
-      template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-      R call( A a, B b, C c, D d, E e, F f, G g ) const
-      {
-         typedef R( FunctionType )( EngineObject*, A, B, C, D, E, F, G );
-         return R( reinterpret_cast< FunctionType* >( const_cast<void*>(mFn) )( mThis, a, b, c, d, e, f, g ) );
-      }
-      
-      template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-      R call( A a, B b, C c, D d, E e, F f, G g, H h ) const
-      {
-         typedef R( FunctionType )( EngineObject*, A, B, C, D, E, F, G, H );
-         return R( reinterpret_cast< FunctionType* >( const_cast<void*>(mFn) )( mThis, a, b, c, d, e, f, g, h ) );
-      }
-      
-      template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
-      R call( A a, B b, C c, D d, E e, F f, G g, H h, I i ) const
-      {
-         typedef R( FunctionType )( EngineObject*, A, B, C, D, E, F, G, H, I );
-         return R( reinterpret_cast< FunctionType* >( const_cast<void*>(mFn) )( mThis, a, b, c, d, e, f, g, h, i ) );
-      }
-      
-      template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J >
-      R call( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j ) const
-      {
-         typedef R( FunctionType )( EngineObject*, A, B, C, D, E, F, G, H, I, J );
-         return R( reinterpret_cast< FunctionType* >( const_cast<void*>(mFn) )( mThis, a, b, c, d, e, f, g, h, i, j ) );
-      }
-      
-      template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K >
-      R call( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k ) const
-      {
-         typedef R( FunctionType )( EngineObject*, A, B, C, D, E, F, G, H, I, J, K );
-         return R( reinterpret_cast< FunctionType* >( const_cast<void*>(mFn) )( mThis, a, b, c, d, e, f, g, h, i, j, k ) );
-      }
-      
-      template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L >
-      R call( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l ) const
-      {
-         typedef R( FunctionType )( EngineObject*, A, B, C, D, E, F, G, H, I, J, K, L );
-         return R( reinterpret_cast< FunctionType* >( const_cast<void*>(mFn) )( mThis, a, b, c, d, e, f, g, h, i, j, k, l ) );
-      }
-      
-};
-
-
-#include "console/stringStack.h"
-
-// Internal helper for callback support in legacy console system.
-struct _BaseEngineConsoleCallbackHelper
-{
-public:
-
-   /// Matches up to storeArgs.
-   static const U32 MAX_ARGUMENTS = 11;
-
-   SimObject* mThis;
-   S32 mInitialArgc;
-   S32 mArgc;
-   StringTableEntry mCallbackName;
-   ConsoleValueRef mArgv[ MAX_ARGUMENTS + 2 ];
-
-   ConsoleValueRef _exec();
-   ConsoleValueRef _execLater(SimConsoleThreadExecEvent *evt);
-
-   _BaseEngineConsoleCallbackHelper() {;}
-};
-
-
-
-// Base helper for console callbacks
-struct _EngineConsoleCallbackHelper : public _BaseEngineConsoleCallbackHelper
-{
-public:
-
-   _EngineConsoleCallbackHelper( StringTableEntry callbackName, SimObject* pThis )
-   {
-      mThis = pThis;
-      mArgc = mInitialArgc = pThis ? 2 : 1 ;
-      mCallbackName = callbackName;
-   }
-
-   template< typename R >
-   R call()
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-
-
-   
-   template< typename R, typename A >
-   R call( A a )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+1, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+1, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B >
-   R call( A a, B b )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+2, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+2, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C >
-   R call( A a, B b, C c )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+3, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+3, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C, typename D >
-   R call( A a, B b, C c, D d )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+4, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+4, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C, typename D, typename E >
-   R call( A a, B b, C c, D d, E e )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+5, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+5, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F >
-   R call( A a, B b, C c, D d, E e, F f )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+6, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+6, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-   R call( A a, B b, C c, D d, E e, F f, G g )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+7, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+7, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-   R call( A a, B b, C c, D d, E e, F f, G g, H h )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+8, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+8, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
-   R call( A a, B b, C c, D d, E e, F f, G g, H h, I i )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+9, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+9, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J >
-   R call( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+10, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-         EngineMarshallData( j, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+10, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-         EngineMarshallData( j, mArgc, mArgv );
-
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K >
-   R call( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+11, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-         EngineMarshallData( j, mArgc, mArgv );
-         EngineMarshallData( k, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+11, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-         EngineMarshallData( j, mArgc, mArgv );
-         EngineMarshallData( k, mArgc, mArgv );
-
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L >
-   R call( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+12, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-         EngineMarshallData( j, mArgc, mArgv );
-         EngineMarshallData( k, mArgc, mArgv );
-         EngineMarshallData( l, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+12, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-         EngineMarshallData( j, mArgc, mArgv );
-         EngineMarshallData( k, mArgc, mArgv );
-         EngineMarshallData( l, mArgc, mArgv );
-
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-};
-
-
-// Override for when first parameter is presumably a SimObject*, in which case A will be absorbed as the callback
-template<typename P1> struct _EngineConsoleExecCallbackHelper : public _BaseEngineConsoleCallbackHelper
-{
-public:
-
-   _EngineConsoleExecCallbackHelper( SimObject* pThis )
-   {
-      mThis = pThis;
-      mArgc = mInitialArgc = 2;
-      mCallbackName = NULL;
-   }
-
-   
-   template< typename R, typename A >
-   R call( A a )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+0, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+0, NULL, true, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         
-
-         Sim::postEvent(mThis, evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B >
-   R call( A a, B b )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+1, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+1, NULL, true, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-
-         Sim::postEvent(mThis, evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C >
-   R call( A a, B b, C c )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+2, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+2, NULL, true, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-
-         Sim::postEvent(mThis, evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C, typename D >
-   R call( A a, B b, C c, D d )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+3, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+3, NULL, true, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-
-         Sim::postEvent(mThis, evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C, typename D, typename E >
-   R call( A a, B b, C c, D d, E e )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+4, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+4, NULL, true, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-
-         Sim::postEvent(mThis, evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F >
-   R call( A a, B b, C c, D d, E e, F f )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+5, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+5, NULL, true, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-
-         Sim::postEvent(mThis, evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-   R call( A a, B b, C c, D d, E e, F f, G g )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+6, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+6, NULL, true, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-
-         Sim::postEvent(mThis, evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-   R call( A a, B b, C c, D d, E e, F f, G g, H h )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+7, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+7, NULL, true, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-
-         Sim::postEvent(mThis, evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
-   R call( A a, B b, C c, D d, E e, F f, G g, H h, I i )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+8, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+8, NULL, true, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
+#define _CHECK_ENGINE_INITIALIZED( fnName, returnType ) _CHECK_ENGINE_INITIALIZED_IMPL( fnName, returnType )
 
-         Sim::postEvent(mThis, evt, Sim::getCurrentTime());
 
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
+/// Define a call-in point for calling into the engine.
+///
+/// @param name The name of the function as it should be seen by the control layer.
+/// @param returnType The value type returned to the control layer.
+/// @param args The argument list as it would appear on the function definition
+/// @param defaultArgs The list of default argument values.
+/// @param usage The usage doc string for the engine API reference.
+///
+/// @code
+/// DefineEngineFunction( myFunction, int, ( float f, const String& s ), ( "value for s" ), "This is my function." )
+/// {
+///    return int( f ) + dAtoi( s );
+/// }
+/// @endcode
+#define DefineEngineFunction( name, returnType, args, defaultArgs, usage )                                                       \
+   static inline returnType _fn ## name ## impl args;                                                                            \
+   TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## name                                                         \
+      ( _EngineFunctionTrampoline< returnType args >::Args a )                                                                   \
+   {                                                                                                                             \
+      _CHECK_ENGINE_INITIALIZED( name, returnType );                                                                             \
+      return EngineTypeTraits< returnType >::ReturnValue(                                                                        \
+         _EngineFunctionTrampoline< returnType args >::jmp( _fn ## name ## impl, a )                                             \
+      );                                                                                                                         \
+   }                                                                                                                             \
+   static _EngineFunctionDefaultArguments< void args > _fn ## name ## DefaultArgs defaultArgs;                                   \
+   static EngineFunctionInfo _fn ## name ## FunctionInfo(                                                                        \
+      #name,                                                                                                                     \
+      &_SCOPE<>()(),                                                                                                             \
+      usage,                                                                                                                     \
+      #returnType " " #name #args,                                                                                               \
+      "fn" #name,                                                                                                                \
+      TYPE< returnType args >(),                                                                                                 \
+      &_fn ## name ## DefaultArgs,                                                                                               \
+      ( void* ) &fn ## name,                                                                                                     \
+      0                                                                                                                          \
+   );                                                                                                                            \
+   static _EngineConsoleThunkType< returnType >::ReturnType _ ## name ## caster( SimObject*, S32 argc, ConsoleValueRef *argv )       \
+   {                                                                                                                             \
+      return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 1, returnType args >::thunk(                \
+         argc, argv, &_fn ## name ## impl, _fn ## name ## DefaultArgs                                                            \
+      ) );                                                                                                                       \
+   }                                                                                                                             \
+   static ConsoleFunctionHeader _ ## name ## header                                                                              \
+      ( #returnType, #args, #defaultArgs );                                                                                      \
+   static ConsoleConstructor                                                                                                     \
+      _ ## name ## obj( NULL, #name, _EngineConsoleThunkType< returnType >::CallbackType( _ ## name ## caster ), usage,          \
+         _EngineConsoleThunk< 1, returnType args >::NUM_ARGS - _EngineConsoleThunkCountArgs() defaultArgs,                       \
+         _EngineConsoleThunk< 1, returnType args >::NUM_ARGS,                                                                    \
+         false, &_ ## name ## header                                                                                             \
+      );                                                                                                                         \
+   static inline returnType _fn ## name ## impl args
    
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J >
-   R call( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+9, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-         EngineMarshallData( j, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+9, NULL, true, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-         EngineMarshallData( j, mArgc, mArgv );
-
-         Sim::postEvent(mThis, evt, Sim::getCurrentTime());
-
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
    
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K >
-   R call( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+10, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-         EngineMarshallData( j, mArgc, mArgv );
-         EngineMarshallData( k, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+10, NULL, true, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-         EngineMarshallData( j, mArgc, mArgv );
-         EngineMarshallData( k, mArgc, mArgv );
-
-         Sim::postEvent(mThis, evt, Sim::getCurrentTime());
+// The next thing is a bit tricky.  DefineEngineMethod allows to make the 'object' (=this) argument to the function
+// implicit which presents quite an obstacle for the macro internals as the engine export system requires the
+// name of a DLL symbol that represents an extern "C" function with an explicit first object pointer argument.
+//
+// Even if we ignored the fact that we don't have a guarantee how the various C++ compilers implement implicit 'this' arguments,
+// we could still not just use a C++ method for this as then we would have to get past the C++ compiler's mangling to
+// get to the function symbol name (let alone the fact that typing this method correctly would be tricky).
+//
+// So, the trick employed here is to package all but the implicit 'this' argument in a structure and then define an
+// extern "C" function that takes the object pointer as a first argument and the struct type as the second argument.
+// This will result in a function with an identical stack call frame layout to the function we want.
+//
+// Unfortunately, that still requires that function to chain on to the real user-defined function.  To do this
+// cleanly and portably, _EngineMethodTrampoline is used to unpack and jump the call from extern "C" into C++ space.
+// In optimized builds, the compiler should be smart enough to pretty much optimize all our trickery here away.
 
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
+#define _DefineMethodTrampoline( className, name, returnType, args ) \
+   TORQUE_API EngineTypeTraits< returnType >::ReturnValueType \
+      fn ## className ## _ ## name ( className* object, _EngineMethodTrampoline< _ ## className ## name ## frame, returnType args >::Args a )   \
+   {                                                                                                                                            \
+      _CHECK_ENGINE_INITIALIZED( className::name, returnType );                                                                                 \
+      return EngineTypeTraits< returnType >::ReturnValue(                                                                                       \
+         _EngineMethodTrampoline< _ ## className ## name ## frame, returnType args >::jmp( object, a )                                          \
+      );                                                                                                                                        \
    }
-   
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L >
-   R call( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+11, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-         EngineMarshallData( j, mArgc, mArgv );
-         EngineMarshallData( k, mArgc, mArgv );
-         EngineMarshallData( l, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+11, NULL, true, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(a);
-
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-         EngineMarshallData( j, mArgc, mArgv );
-         EngineMarshallData( k, mArgc, mArgv );
-         EngineMarshallData( l, mArgc, mArgv );
 
-         Sim::postEvent(mThis, evt, Sim::getCurrentTime());
 
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
+/// Define a call-in point for calling a method on an engine object.
+///
+/// @param name The name of the C++ class.
+/// @param name The name of the method as it should be seen by the control layer.
+/// @param returnType The value type returned to the control layer.
+/// @param args The argument list as it would appear on the function definition
+/// @param defaultArgs The list of default argument values.
+/// @param usage The usage doc string for the engine API reference.
+///
+/// @code
+/// DefineEngineMethod( MyClass, myMethod, int, ( float f, const String& s ), ( "value for s" ), "This is my method." )
+/// {
+///    return object->someMethod( f, s );
+/// }
+/// @endcode
+#define DefineEngineMethod( className, name, returnType, args, defaultArgs, usage )                                                             \
+   struct _ ## className ## name ## frame                                                                                                       \
+   {                                                                                                                                            \
+      typedef className ObjectType;                                                                                                             \
+      className* object;                                                                                                                        \
+      inline returnType _exec args const;                                                                                                       \
+   };                                                                                                                                           \
+   _DefineMethodTrampoline( className, name, returnType, args );                                                                                \
+   static _EngineFunctionDefaultArguments< _EngineMethodTrampoline< _ ## className ## name ## frame, void args >::FunctionType >                \
+      _fn ## className ## name ## DefaultArgs defaultArgs;                                                                                      \
+   static EngineFunctionInfo _fn ## className ## name ## FunctionInfo(                                                                          \
+      #name,                                                                                                                                    \
+      &_SCOPE< className >()(),                                                                                                                 \
+      usage,                                                                                                                                    \
+      "virtual " #returnType " " #name #args,                                                                                                   \
+      "fn" #className "_" #name,                                                                                                                \
+      TYPE< _EngineMethodTrampoline< _ ## className ## name ## frame, returnType args >::FunctionType >(),                                      \
+      &_fn ## className ## name ## DefaultArgs,                                                                                                 \
+      ( void* ) &fn ## className ## _ ## name,                                                                                                  \
+      0                                                                                                                                         \
+   );                                                                                                                                           \
+   static _EngineConsoleThunkType< returnType >::ReturnType _ ## className ## name ## caster( SimObject* object, S32 argc, ConsoleValueRef *argv )  \
+   {                                                                                                                                            \
+      _ ## className ## name ## frame frame;                                                                                                    \
+      frame.object = static_cast< className* >( object );                                                                                       \
+      return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 2, returnType args >::thunk(                               \
+         argc, argv, &_ ## className ## name ## frame::_exec, &frame, _fn ## className ## name ## DefaultArgs                                   \
+      ) );                                                                                                                                      \
+   }                                                                                                                                            \
+   static ConsoleFunctionHeader _ ## className ## name ## header                                                                                \
+      ( #returnType, #args, #defaultArgs );                                                                                                     \
+   static ConsoleConstructor                                                                                                                    \
+      className ## name ## obj( #className, #name,                                                                                              \
+         _EngineConsoleThunkType< returnType >::CallbackType( _ ## className ## name ## caster ), usage,                                        \
+         _EngineConsoleThunk< 2, returnType args >::NUM_ARGS - _EngineConsoleThunkCountArgs() defaultArgs,                                      \
+         _EngineConsoleThunk< 2, returnType args >::NUM_ARGS,                                                                                   \
+         false, &_ ## className ## name ## header                                                                                               \
+      );                                                                                                                                        \
+   returnType _ ## className ## name ## frame::_exec args const
    
-};
-
-// Override for when first parameter is const char*
-template<> struct _EngineConsoleExecCallbackHelper<const char*> : public _BaseEngineConsoleCallbackHelper
-{
-   _EngineConsoleExecCallbackHelper( const char *callbackName )
-   {
-      mThis = NULL;
-      mArgc = mInitialArgc = 1;
-      mCallbackName = StringTable->insert(callbackName);
-   }
-
-   template< typename R >
-   R call()
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-
-
    
-   template< typename R, typename A >
-   R call( A a )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+1, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
+/// Define a call-in point for calling into the engine.  Unlike with DefineEngineFunction, the statically
+/// callable function will be confined to the namespace of the given class.
+///
+/// @param name The name of the C++ class (or a registered export scope).
+/// @param name The name of the method as it should be seen by the control layer.
+/// @param returnType The value type returned to the control layer.
+/// @param args The argument list as it would appear on the function definition
+/// @param defaultArgs The list of default argument values.
+/// @param usage The usage doc string for the engine API reference.
+///
+/// @code
+/// DefineEngineStaticMethod( MyClass, myMethod, int, ( float f, string s ), ( "value for s" ), "This is my method." )
+/// {
+/// }
+/// @endcode
+#define DefineEngineStaticMethod( className, name, returnType, args, defaultArgs, usage )                                              \
+   static inline returnType _fn ## className ## name ## impl args;                                                                     \
+   TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## className ## _ ## name                                             \
+      ( _EngineFunctionTrampoline< returnType args >::Args a )                                                                         \
+   {                                                                                                                                   \
+      _CHECK_ENGINE_INITIALIZED( className::name, returnType );                                                                        \
+      return EngineTypeTraits< returnType >::ReturnValue(                                                                              \
+         _EngineFunctionTrampoline< returnType args >::jmp( _fn ## className ## name ## impl, a )                                      \
+      );                                                                                                                               \
+   }                                                                                                                                   \
+   static _EngineFunctionDefaultArguments< void args > _fn ## className ## name ## DefaultArgs defaultArgs;                            \
+   static EngineFunctionInfo _fn ## name ## FunctionInfo(                                                                              \
+      #name,                                                                                                                           \
+      &_SCOPE< className >()(),                                                                                                        \
+      usage,                                                                                                                           \
+      #returnType " " #name #args,                                                                                                     \
+      "fn" #className "_" #name,                                                                                                       \
+      TYPE< returnType args >(),                                                                                                       \
+      &_fn ## className ## name ## DefaultArgs,                                                                                        \
+      ( void* ) &fn ## className ## _ ## name,                                                                                         \
+      0                                                                                                                                \
+   );                                                                                                                                  \
+   static _EngineConsoleThunkType< returnType >::ReturnType _ ## className ## name ## caster( SimObject*, S32 argc, ConsoleValueRef *argv )\
+   {                                                                                                                                   \
+      return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 1, returnType args >::thunk(                      \
+         argc, argv, &_fn ## className ## name ## impl, _fn ## className ## name ## DefaultArgs                                        \
+      ) );                                                                                                                             \
+   }                                                                                                                                   \
+   static ConsoleFunctionHeader _ ## className ## name ## header                                                                       \
+      ( #returnType, #args, #defaultArgs, true );                                                                                      \
+   static ConsoleConstructor                                                                                                           \
+      _ ## className ## name ## obj( #className, #name, _EngineConsoleThunkType< returnType >::CallbackType( _ ## className ## name ## caster ), usage, \
+         _EngineConsoleThunk< 1, returnType args >::NUM_ARGS - _EngineConsoleThunkCountArgs() defaultArgs,                             \
+         _EngineConsoleThunk< 1, returnType args >::NUM_ARGS,                                                                          \
+         false, &_ ## className ## name ## header                                                                                      \
+      );                                                                                                                               \
+   static inline returnType _fn ## className ## name ## impl args
 
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+1, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
 
-         EngineMarshallData( a, mArgc, mArgv );
+// Convenience macros to allow defining functions that use the new marshalling features
+// while being only visible in the console interop.  When we drop the console system,
+// these macros can be removed and all definitions that make use of them can be removed
+// as well.
+#define DefineConsoleFunction( name, returnType, args, defaultArgs, usage )                                                      \
+   static inline returnType _fn ## name ## impl args;                                                                            \
+   static _EngineFunctionDefaultArguments< void args > _fn ## name ## DefaultArgs defaultArgs;                                   \
+   static _EngineConsoleThunkType< returnType >::ReturnType _ ## name ## caster( SimObject*, S32 argc, ConsoleValueRef *argv )       \
+   {                                                                                                                             \
+      return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 1, returnType args >::thunk(                \
+         argc, argv, &_fn ## name ## impl, _fn ## name ## DefaultArgs                                                            \
+      ) );                                                                                                                       \
+   }                                                                                                                             \
+   static ConsoleFunctionHeader _ ## name ## header                                                                              \
+      ( #returnType, #args, #defaultArgs );                                                                                      \
+   static ConsoleConstructor                                                                                                     \
+      _ ## name ## obj( NULL, #name, _EngineConsoleThunkType< returnType >::CallbackType( _ ## name ## caster ), usage,          \
+         _EngineConsoleThunk< 1, returnType args >::NUM_ARGS - _EngineConsoleThunkCountArgs() defaultArgs,                       \
+         _EngineConsoleThunk< 1, returnType args >::NUM_ARGS,                                                                    \
+         false, &_ ## name ## header                                                                                             \
+      );                                                                                                                         \
+   static inline returnType _fn ## name ## impl args
 
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
+#define DefineConsoleMethod( className, name, returnType, args, defaultArgs, usage )                                                            \
+   struct _ ## className ## name ## frame                                                                                                       \
+   {                                                                                                                                            \
+      typedef className ObjectType;                                                                                                             \
+      className* object;                                                                                                                        \
+      inline returnType _exec args const;                                                                                                       \
+   };                                                                                                                                           \
+   static _EngineFunctionDefaultArguments< _EngineMethodTrampoline< _ ## className ## name ## frame, void args >::FunctionType >                \
+      _fn ## className ## name ## DefaultArgs defaultArgs;                                                                                      \
+   static _EngineConsoleThunkType< returnType >::ReturnType _ ## className ## name ## caster( SimObject* object, S32 argc, ConsoleValueRef *argv )  \
+   {                                                                                                                                            \
+      _ ## className ## name ## frame frame;                                                                                                    \
+      frame.object = static_cast< className* >( object );                                                                                       \
+      return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 2, returnType args >::thunk(                               \
+         argc, argv, &_ ## className ## name ## frame::_exec, &frame, _fn ## className ## name ## DefaultArgs                                   \
+      ) );                                                                                                                                      \
+   }                                                                                                                                            \
+   static ConsoleFunctionHeader _ ## className ## name ## header                                                                                \
+      ( #returnType, #args, #defaultArgs );                                                                                                     \
+   static ConsoleConstructor                                                                                                                    \
+      className ## name ## obj( #className, #name,                                                                                              \
+         _EngineConsoleThunkType< returnType >::CallbackType( _ ## className ## name ## caster ), usage,                                        \
+         _EngineConsoleThunk< 2, returnType args >::NUM_ARGS - _EngineConsoleThunkCountArgs() defaultArgs,                                      \
+         _EngineConsoleThunk< 2, returnType args >::NUM_ARGS,                                                                                   \
+         false, &_ ## className ## name ## header                                                                                               \
+      );                                                                                                                                        \
+   returnType _ ## className ## name ## frame::_exec args const
 
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B >
-   R call( A a, B b )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+2, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
+#define DefineConsoleStaticMethod( className, name, returnType, args, defaultArgs, usage )                                             \
+   static inline returnType _fn ## className ## name ## impl args;                                                                     \
+   static _EngineFunctionDefaultArguments< void args > _fn ## className ## name ## DefaultArgs defaultArgs;                            \
+   static _EngineConsoleThunkType< returnType >::ReturnType _ ## className ## name ## caster( SimObject*, S32 argc, ConsoleValueRef *argv )\
+   {                                                                                                                                   \
+      return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 1, returnType args >::thunk(                      \
+         argc, argv, &_fn ## className ## name ## impl, _fn ## className ## name ## DefaultArgs                                        \
+      ) );                                                                                                                             \
+   }                                                                                                                                   \
+   static ConsoleFunctionHeader _ ## className ## name ## header                                                                       \
+      ( #returnType, #args, #defaultArgs, true );                                                                                      \
+   static ConsoleConstructor                                                                                                           \
+      _ ## className ## name ## obj( #className, #name, _EngineConsoleThunkType< returnType >::CallbackType( _ ## className ## name ## caster ), usage, \
+         _EngineConsoleThunk< 1, returnType args >::NUM_ARGS - _EngineConsoleThunkCountArgs() defaultArgs,                             \
+         _EngineConsoleThunk< 1, returnType args >::NUM_ARGS,                                                                          \
+         false, &_ ## className ## name ## header                                                                                      \
+      );                                                                                                                               \
+   static inline returnType _fn ## className ## name ## impl args
 
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
 
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+2, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
+// The following three macros are only temporary.  They allow to define engineAPI functions using the framework
+// here in this file while being visible only in the new API.  When the console interop is removed, these macros
+// can be removed and all their uses be replaced with their corresponding versions that now still include support
+// for the console (e.g. DefineNewEngineFunction should become DefineEngineFunction).
+#define DefineNewEngineFunction( name, returnType, args, defaultArgs, usage )                                                    \
+   static inline returnType _fn ## name ## impl args;                                                                            \
+   TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## name                                                         \
+      ( _EngineFunctionTrampoline< returnType args >::Args a )                                                                   \
+   {                                                                                                                             \
+      _CHECK_ENGINE_INITIALIZED( name, returnType );                                                                             \
+      return EngineTypeTraits< returnType >::ReturnValue(                                                                        \
+         _EngineFunctionTrampoline< returnType args >::jmp( _fn ## name ## impl, a )                                             \
+      );                                                                                                                         \
+   }                                                                                                                             \
+   static _EngineFunctionDefaultArguments< void args > _fn ## name ## DefaultArgs defaultArgs;                                   \
+   static EngineFunctionInfo _fn ## name ## FunctionInfo(                                                                        \
+      #name,                                                                                                                     \
+      &_SCOPE<>()(),                                                                                                             \
+      usage,                                                                                                                     \
+      #returnType " " #name #args,                                                                                               \
+      "fn" #name,                                                                                                                \
+      TYPE< returnType args >(),                                                                                                 \
+      &_fn ## name ## DefaultArgs,                                                                                               \
+      ( void* ) &fn ## name,                                                                                                     \
+      0                                                                                                                          \
+   );                                                                                                                            \
+   static inline returnType _fn ## name ## impl args
 
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
+#define DefineNewEngineMethod( className, name, returnType, args, defaultArgs, usage )                                                          \
+   struct _ ## className ## name ## frame                                                                                                       \
+   {                                                                                                                                            \
+      typedef className ObjectType;                                                                                                             \
+      className* object;                                                                                                                        \
+      inline returnType _exec args const;                                                                                                       \
+   };                                                                                                                                           \
+   _DefineMethodTrampoline( className, name, returnType, args );                                                                                \
+   static _EngineFunctionDefaultArguments< _EngineMethodTrampoline< _ ## className ## name ## frame, void args >::FunctionType >                \
+      _fn ## className ## name ## DefaultArgs defaultArgs;                                                                                      \
+   static EngineFunctionInfo _fn ## className ## name ## FunctionInfo(                                                                          \
+      #name,                                                                                                                                    \
+      &_SCOPE< className >()(),                                                                                                                 \
+      usage,                                                                                                                                    \
+      "virtual " #returnType " " #name #args,                                                                                                   \
+      "fn" #className "_" #name,                                                                                                                \
+      TYPE< _EngineMethodTrampoline< _ ## className ## name ## frame, returnType args >::FunctionType >(),                                      \
+      &_fn ## className ## name ## DefaultArgs,                                                                                                 \
+      ( void* ) &fn ## className ## _ ## name,                                                                                                  \
+      0                                                                                                                                         \
+   );                                                                                                                                           \
+   returnType _ ## className ## name ## frame::_exec args const
 
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
+#define DefineNewEngineStaticMethod( className, name, returnType, args, defaultArgs, usage )                                           \
+   static inline returnType _fn ## className ## name ## impl args;                                                                     \
+   TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## className ## _ ## name                                             \
+      ( _EngineFunctionTrampoline< returnType args >::Args a )                                                                         \
+   {                                                                                                                                   \
+      _CHECK_ENGINE_INITIALIZED( className::name, returnType );                                                                        \
+      return EngineTypeTraits< returnType >::ReturnValue(                                                                              \
+         _EngineFunctionTrampoline< returnType args >::jmp( _fn ## className ## name ## impl, a )                                      \
+      );                                                                                                                               \
+   }                                                                                                                                   \
+   static _EngineFunctionDefaultArguments< void args > _fn ## className ## name ## DefaultArgs defaultArgs;                            \
+   static EngineFunctionInfo _fn ## name ## FunctionInfo(                                                                              \
+      #name,                                                                                                                           \
+      &_SCOPE< className >()(),                                                                                                        \
+      usage,                                                                                                                           \
+      #returnType " " #name #args,                                                                                                     \
+      "fn" #className "_" #name,                                                                                                       \
+      TYPE< returnType args >(),                                                                                                       \
+      &_fn ## className ## name ## DefaultArgs,                                                                                        \
+      ( void* ) &fn ## className ## _ ## name,                                                                                         \
+      0                                                                                                                                \
+   );                                                                                                                                  \
+   static inline returnType _fn ## className ## name ## impl args
 
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C >
-   R call( A a, B b, C c )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+3, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
+/// @}
 
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
 
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+3, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
+//=============================================================================
+//    Callbacks.
+//=============================================================================
 
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
+/// Matching implement for DECLARE_CALLBACK.
+///
+///
+/// @warn With the new interop system, method-style callbacks <em>must not</em> be triggered on object
+///   that are being created!  This is because the control layer will likely not yet have a fully valid wrapper
+///   object in place for the EngineObject under construction.
+#define IMPLEMENT_CALLBACK( class, name, returnType, args, argNames, usageString )                                                           \
+   struct _ ## class ## name ## frame { typedef class ObjectType; };                                                                         \
+   TORQUE_API _EngineMethodTrampoline< _ ## class ## name ## frame, returnType args >::FunctionType* cb ## class ## _ ## name;               \
+   TORQUE_API void set_cb ## class ## _ ## name(                                                                                             \
+      _EngineMethodTrampoline< _ ## class ## name ## frame, returnType args >::FunctionType fn )                                             \
+      { cb ## class ## _ ## name = fn; }                                                                                                     \
+   _EngineMethodTrampoline< _ ## class ## name ## frame, returnType args >::FunctionType* cb ## class ## _ ## name;                          \
+   namespace {                                                                                                                               \
+      ::EngineFunctionInfo _cb ## class ## name(                                                                                             \
+         #name,                                                                                                                              \
+         &::_SCOPE< class >()(),                                                                                                             \
+         usageString,                                                                                                                        \
+         "virtual " #returnType " " #name #args,                                                                                             \
+         "cb" #class "_" #name,                                                                                                              \
+         ::TYPE< _EngineMethodTrampoline< _ ## class ## name ## frame, returnType args >::FunctionType >(),                                  \
+         NULL,                                                                                                                               \
+         ( void* ) &cb ## class ## _ ## name,                                                                                                \
+         EngineFunctionCallout                                                                                                               \
+      );                                                                                                                                     \
+   }                                                                                                                                         \
+   returnType class::name ## _callback args                                                                                                  \
+   {                                                                                                                                         \
+      if( cb ## class ## _ ## name ) {                                                                                                       \
+         _EngineCallbackHelper cbh( this, reinterpret_cast< const void* >( cb ## class ## _ ## name ) );                                     \
+         return returnType( cbh.call< returnType > argNames );                                                                               \
+      }                                                                                                                                      \
+      if( engineAPI::gUseConsoleInterop )                                                                                                    \
+      {                                                                                                                                      \
+         static StringTableEntry sName = StringTable->insert( #name );                                                                       \
+         _EngineConsoleCallbackHelper cbh( sName, this );                                                                                    \
+         return returnType( cbh.call< returnType > argNames );                                                                               \
+      }                                                                                                                                      \
+      return returnType();                                                                                                                   \
+   }                                                                                                                                         \
+   namespace {                                                                                                                               \
+      ConsoleFunctionHeader _ ## class ## name ## header(                                                                                    \
+         #returnType, #args, "" );                                                                                                           \
+      ConsoleConstructor _ ## class ## name ## obj( #class, #name, usageString, &_ ## class ## name ## header );                             \
+   }
 
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
 
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
+/// Used to define global callbacks not associated with 
+/// any particular class or namespace.
+#define IMPLEMENT_GLOBAL_CALLBACK( name, returnType, args, argNames, usageString )                                                           \
+   DEFINE_CALLOUT( cb ## name, name,, returnType, args, 0, usageString );                                                                    \
+   returnType name ## _callback args                                                                                                         \
+   {                                                                                                                                         \
+      if( cb ## name )                                                                                                                       \
+         return returnType( cb ## name argNames );                                                                                           \
+      if( engineAPI::gUseConsoleInterop )                                                                                                    \
+      {                                                                                                                                      \
+         static StringTableEntry sName = StringTable->insert( #name );                                                                       \
+         _EngineConsoleCallbackHelper cbh( sName, NULL );                                                                                    \
+         return returnType( cbh.call< returnType > argNames );                                                                               \
+      }                                                                                                                                      \
+      return returnType();                                                                                                                   \
+   }                                                                                                                                         \
+   namespace {                                                                                                                               \
+      ConsoleFunctionHeader _ ## name ## header(                                                                                             \
+         #returnType, #args, "" );                                                                                                           \
+      ConsoleConstructor _ ## name ## obj( NULL, #name, usageString, &_ ## name ## header );                                                 \
    }
    
-   template< typename R, typename A, typename B, typename C, typename D >
-   R call( A a, B b, C c, D d )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+4, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+4, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
+   
+// Again, temporary macros to allow splicing the API while we still have the console interop around.
 
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
+#define IMPLEMENT_CONSOLE_CALLBACK( class, name, returnType, args, argNames, usageString )                                                   \
+   returnType class::name ## _callback args                                                                                                  \
+   {                                                                                                                                         \
+      if( engineAPI::gUseConsoleInterop )                                                                                                    \
+      {                                                                                                                                      \
+         static StringTableEntry sName = StringTable->insert( #name );                                                                       \
+         _EngineConsoleCallbackHelper cbh( sName, this );                                                                                    \
+         return returnType( cbh.call< returnType > argNames );                                                                               \
+      }                                                                                                                                      \
+      return returnType();                                                                                                                   \
+   }                                                                                                                                         \
+   namespace {                                                                                                                               \
+      ConsoleFunctionHeader _ ## class ## name ## header(                                                                                    \
+         #returnType, #args, "" );                                                                                                           \
+      ConsoleConstructor _ ## class ## name ## obj( #class, #name, usageString, &_ ## class ## name ## header );                             \
    }
    
-   template< typename R, typename A, typename B, typename C, typename D, typename E >
-   R call( A a, B b, C c, D d, E e )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+5, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
+#define IMPLEMENT_NEW_CALLBACK( class, name, returnType, args, argNames, usageString )                                                       \
+   struct _ ## class ## name ## frame { typedef class ObjectType; };                                                                         \
+   TORQUE_API _EngineMethodTrampoline< _ ## class ## name ## frame, returnType args >::FunctionType* cb ## class ## _ ## name;               \
+   TORQUE_API void set_cb ## class ## _ ## name(                                                                                             \
+      _EngineMethodTrampoline< _ ## class ## name ## frame, returnType args >::FunctionType fn )                                             \
+      { cb ## class ## _ ## name = fn; }                                                                                                     \
+   _EngineMethodTrampoline< _ ## class ## name ## frame, returnType args >::FunctionType* cb ## class ## _ ## name;                          \
+   namespace {                                                                                                                               \
+      ::EngineFunctionInfo _cb ## class ## name(                                                                                             \
+         #name,                                                                                                                              \
+         &::_SCOPE< class >()(),                                                                                                             \
+         usageString,                                                                                                                        \
+         "virtual " #returnType " " #name #args,                                                                                             \
+         "cb" #class "_" #name,                                                                                                              \
+         ::TYPE< _EngineMethodTrampoline< _ ## class ## name ## frame, returnType args >::FunctionType >(),                                  \
+         NULL,                                                                                                                               \
+         &cb ## class ## _ ## name,                                                                                                          \
+         EngineFunctionCallout                                                                                                               \
+      );                                                                                                                                     \
+   }                                                                                                                                         \
+   returnType class::name ## _callback args                                                                                                  \
+   {                                                                                                                                         \
+      if( cb ## class ## _ ## name ) {                                                                                                       \
+         _EngineCallbackHelper cbh( this, reinterpret_cast< const void* >( cb ## class ## _ ## name ) );                                     \
+         return returnType( cbh.call< returnType > argNames );                                                                               \
+      }                                                                                                                                      \
+      return returnType();                                                                                                                   \
+   }
 
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
 
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+5, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
 
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
 
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
+// Internal helper class for doing call-outs in the new interop.
+struct _EngineCallbackHelper
+{
+   protected:
+    
+      EngineObject* mThis;
+      const void* mFn;
+            
+   public:
 
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F >
-   R call( A a, B b, C c, D d, E e, F f )
-   {
-      if (Con::isMainThread())
+      _EngineCallbackHelper( EngineObject* pThis, const void* fn )
+         : mThis( pThis ),
+           mFn( fn ) {}
+      
+      template< typename R, typename ...ArgTs >
+      R call(ArgTs ...args) const
       {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+6, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
+         typedef R( FunctionType )( EngineObject*, ArgTs... );
+         return R( reinterpret_cast< FunctionType* >( const_cast<void*>(mFn) )( mThis, args... ) );
       }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+6, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
 
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
+};
 
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-   R call( A a, B b, C c, D d, E e, F f, G g )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+7, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
 
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
+#include "console/stringStack.h"
 
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+7, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
+// Internal helper for callback support in legacy console system.
+struct _BaseEngineConsoleCallbackHelper
+{
+public:
 
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
+   /// Matches up to storeArgs.
+   static const U32 MAX_ARGUMENTS = 11;
 
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
+   SimObject* mThis;
+   S32 mInitialArgc;
+   S32 mArgc;
+   StringTableEntry mCallbackName;
+   ConsoleValueRef mArgv[ MAX_ARGUMENTS + 2 ];
 
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
-   }
-   
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-   R call( A a, B b, C c, D d, E e, F f, G g, H h )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+8, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
+   ConsoleValueRef _exec();
+   ConsoleValueRef _execLater(SimConsoleThreadExecEvent *evt);
 
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
+   _BaseEngineConsoleCallbackHelper() {;}
+};
 
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+8, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
 
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
 
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
+// Base helper for console callbacks
+struct _EngineConsoleCallbackHelper : public _BaseEngineConsoleCallbackHelper
+{
+private:
+   using Helper = engineAPI::detail::MarshallHelpers<ConsoleValueRef>;
+public:
 
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
+   _EngineConsoleCallbackHelper( StringTableEntry callbackName, SimObject* pThis )
+   {
+      mThis = pThis;
+      mArgc = mInitialArgc = pThis ? 2 : 1 ;
+      mCallbackName = callbackName;
    }
    
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
-   R call( A a, B b, C c, D d, E e, F f, G g, H h, I i )
+   template< typename R, typename ...ArgTs >
+   R call(ArgTs ...args)
    {
       if (Con::isMainThread())
       {
          ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+9, mArgv);
+         CSTK.reserveValues(mArgc + sizeof...(ArgTs), mArgv);
          mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-
+        
+        Helper::marshallEach(mArgc, mArgv, args...);
+        
          return R( EngineUnmarshallData< R >()( _exec() ) );
       }
       else
       {
          SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+9, NULL, false, &cb);
+         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc + sizeof...(ArgTs), NULL, false, &cb);
          evt->populateArgs(mArgv);
          mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-
+        
+        Helper::marshallEach(mArgc, mArgv, args...);
+        
          Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
 
          return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
       }
    }
    
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J >
-   R call( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j )
-   {
-      if (Con::isMainThread())
-      {
-         ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+10, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-         EngineMarshallData( j, mArgc, mArgv );
-
-         return R( EngineUnmarshallData< R >()( _exec() ) );
-      }
-      else
-      {
-         SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+10, NULL, false, &cb);
-         evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
+};
 
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-         EngineMarshallData( j, mArgc, mArgv );
 
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
+// Override for when first parameter is presumably a SimObject*, in which case A will be absorbed as the callback
+template<typename P1> struct _EngineConsoleExecCallbackHelper : public _BaseEngineConsoleCallbackHelper
+{
+private:
+   using Helper = engineAPI::detail::MarshallHelpers<ConsoleValueRef>;
+public:
 
-         return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
-      }
+   _EngineConsoleExecCallbackHelper( SimObject* pThis )
+   {
+      mThis = pThis;
+      mArgc = mInitialArgc = 2;
+      mCallbackName = NULL;
    }
+
    
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K >
-   R call( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k )
+   template< typename R, typename SCB, typename ...ArgTs >
+   R call( SCB simCB , ArgTs ...args )
    {
       if (Con::isMainThread())
       {
          ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+11, mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
+         CSTK.reserveValues(mArgc+sizeof...(ArgTs), mArgv);
+         mArgv[ 0 ].value->setStackStringValue(simCB);
 
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-         EngineMarshallData( j, mArgc, mArgv );
-         EngineMarshallData( k, mArgc, mArgv );
+        Helper::marshallEach(mArgc, mArgv, args...);
 
          return R( EngineUnmarshallData< R >()( _exec() ) );
       }
       else
       {
          SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+11, NULL, false, &cb);
+         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+sizeof...(ArgTs), NULL, true, &cb);
          evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-         EngineMarshallData( j, mArgc, mArgv );
-         EngineMarshallData( k, mArgc, mArgv );
+         mArgv[ 0 ].value->setStackStringValue(simCB);
+        
+        Helper::marshallEach(mArgc, mArgv, args...);
 
-         Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
+         Sim::postEvent(mThis, evt, Sim::getCurrentTime());
 
          return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
       }
    }
-   
-   template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L >
-   R call( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l )
+};
+
+// Override for when first parameter is const char*
+template<> struct _EngineConsoleExecCallbackHelper<const char*> : public _BaseEngineConsoleCallbackHelper
+{
+private:
+   using Helper = engineAPI::detail::MarshallHelpers<ConsoleValueRef>;
+public:
+   _EngineConsoleExecCallbackHelper( const char *callbackName )
+   {
+      mThis = NULL;
+      mArgc = mInitialArgc = 1;
+      mCallbackName = StringTable->insert(callbackName);
+   }
+
+   template< typename R, typename ...ArgTs >
+   R call(ArgTs ...args)
    {
       if (Con::isMainThread())
       {
          ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+12, mArgv);
+         CSTK.reserveValues(mArgc+sizeof...(ArgTs), mArgv);
          mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-         EngineMarshallData( j, mArgc, mArgv );
-         EngineMarshallData( k, mArgc, mArgv );
-         EngineMarshallData( l, mArgc, mArgv );
-
+        
+        Helper::marshallEach(mArgc, mArgv, args...);
+        
          return R( EngineUnmarshallData< R >()( _exec() ) );
       }
       else
       {
          SimConsoleThreadExecCallback cb;
-         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+12, NULL, false, &cb);
+         SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+sizeof...(ArgTs), NULL, false, &cb);
          evt->populateArgs(mArgv);
          mArgv[ 0 ].value->setStackStringValue(mCallbackName);
-
-         EngineMarshallData( a, mArgc, mArgv );
-         EngineMarshallData( b, mArgc, mArgv );
-         EngineMarshallData( c, mArgc, mArgv );
-         EngineMarshallData( d, mArgc, mArgv );
-         EngineMarshallData( e, mArgc, mArgv );
-         EngineMarshallData( f, mArgc, mArgv );
-         EngineMarshallData( g, mArgc, mArgv );
-         EngineMarshallData( h, mArgc, mArgv );
-         EngineMarshallData( i, mArgc, mArgv );
-         EngineMarshallData( j, mArgc, mArgv );
-         EngineMarshallData( k, mArgc, mArgv );
-         EngineMarshallData( l, mArgc, mArgv );
+        
+        Helper::marshallEach(mArgc, mArgv, args...);
 
          Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
-
          return R( EngineUnmarshallData< R >()( cb.waitForResult() ) );
       }
-   }
-   
+   }   
 };
 
 // Re-enable some VC warnings we disabled for this file.
 #pragma warning( pop ) // 4510 and 4610
 
-#endif // !_ENGINEAPI_H_
+#endif // !_ENGINEAPI_H_

Engine/source/console/engineFunctions.h

@@ -23,6 +23,8 @@
 #ifndef _ENGINEFUNCTIONS_H_
 #define _ENGINEFUNCTIONS_H_
 
+#include <tuple>
+
 #ifndef _ENGINEEXPORTS_H_
    #include "console/engineExports.h"
 #endif
@@ -87,693 +89,38 @@ struct EngineFunctionDefaultArguments
 // Structure encapsulating default arguments to an engine API function.
 template< typename T >
 struct _EngineFunctionDefaultArguments {};
-template<>
-struct _EngineFunctionDefaultArguments< void() > : public EngineFunctionDefaultArguments
-{
-   _EngineFunctionDefaultArguments()
-      { mNumDefaultArgs = 0; }
-};
-template< typename A >
-struct _EngineFunctionDefaultArguments< void( A ) > : public EngineFunctionDefaultArguments
-{
-   typename EngineTypeTraits< A >::DefaultArgumentValueStoreType a;
-   
-   _EngineFunctionDefaultArguments()
-      { mNumDefaultArgs = 0; }
-   _EngineFunctionDefaultArguments( A a )
-      : a( a )
-      { mNumDefaultArgs = 1; }
-};
-template< typename A, typename B >
-struct _EngineFunctionDefaultArguments< void( A, B ) > : public EngineFunctionDefaultArguments
-{
-   typename EngineTypeTraits< A >::DefaultArgumentValueStoreType a;
-   typename EngineTypeTraits< B >::DefaultArgumentValueStoreType b;
-   
-   _EngineFunctionDefaultArguments()
-      { mNumDefaultArgs = 0; }
-   _EngineFunctionDefaultArguments( B b )
-      : b( b )
-      { mNumDefaultArgs = 1; }
-   _EngineFunctionDefaultArguments( A a, B b )
-      : a( a ),
-        b( b )
-      { mNumDefaultArgs = 2; }
-};
-template< typename A, typename B, typename C >
-struct _EngineFunctionDefaultArguments< void( A, B, C ) > : public EngineFunctionDefaultArguments
-{
-   typename EngineTypeTraits< A >::DefaultArgumentValueStoreType a;
-   typename EngineTypeTraits< B >::DefaultArgumentValueStoreType b;
-   typename EngineTypeTraits< C >::DefaultArgumentValueStoreType c;
-   
-   _EngineFunctionDefaultArguments()
-      { mNumDefaultArgs = 0; }
-   _EngineFunctionDefaultArguments( C c )
-      : c( c )
-      { mNumDefaultArgs = 1; }
-   _EngineFunctionDefaultArguments( B b, C c )
-      : b( b ),
-        c( c )
-      { mNumDefaultArgs = 2; }
-   _EngineFunctionDefaultArguments( A a, B b, C c )
-      : a( a ),
-        b( b ),
-        c( c )
-      { mNumDefaultArgs = 3; }
-};
-template< typename A, typename B, typename C, typename D >
-struct _EngineFunctionDefaultArguments< void( A, B, C, D ) > : public EngineFunctionDefaultArguments
+
+template<typename ...ArgTs>
+struct _EngineFunctionDefaultArguments< void(ArgTs...) > : public EngineFunctionDefaultArguments
 {
-   typename EngineTypeTraits< A >::DefaultArgumentValueStoreType a;
-   typename EngineTypeTraits< B >::DefaultArgumentValueStoreType b;
-   typename EngineTypeTraits< C >::DefaultArgumentValueStoreType c;
-   typename EngineTypeTraits< D >::DefaultArgumentValueStoreType d;
+   template<typename T> using DefVST = typename EngineTypeTraits<T>::DefaultArgumentValueStoreType;
+   std::tuple<DefVST<ArgTs>  ...> mArgs;
+private:
+   using SelfType = _EngineFunctionDefaultArguments< void(ArgTs...) >;
    
-   _EngineFunctionDefaultArguments()
-      { mNumDefaultArgs = 0; }
-   _EngineFunctionDefaultArguments( D d )
-      : d( d )
-      { mNumDefaultArgs = 1; }
-   _EngineFunctionDefaultArguments( C c, D d )
-      : c( c ),
-        d( d )
-      { mNumDefaultArgs = 2; }
-   _EngineFunctionDefaultArguments( B b, C c, D d )
-      : b( b ),
-        c( c ),
-        d( d )
-      { mNumDefaultArgs = 3; }
-   _EngineFunctionDefaultArguments( A a, B b, C c, D d )
-      : a( a ),
-        b( b ),
-        c( c ),
-        d( d )
-      { mNumDefaultArgs = 4; }
-};
-template< typename A, typename B, typename C, typename D, typename E >
-struct _EngineFunctionDefaultArguments< void( A, B, C, D, E ) > : public EngineFunctionDefaultArguments
-{
-   typename EngineTypeTraits< A >::DefaultArgumentValueStoreType a;
-   typename EngineTypeTraits< B >::DefaultArgumentValueStoreType b;
-   typename EngineTypeTraits< C >::DefaultArgumentValueStoreType c;
-   typename EngineTypeTraits< D >::DefaultArgumentValueStoreType d;
-   typename EngineTypeTraits< E >::DefaultArgumentValueStoreType e;
+   template<size_t ...> struct Seq {};
+   template<size_t N, size_t ...S> struct Gens : Gens<N-1, N-1, S...> {};
    
-   _EngineFunctionDefaultArguments()
-      { mNumDefaultArgs = 0; }
-   _EngineFunctionDefaultArguments( E e )
-      : e( e )
-      { mNumDefaultArgs = 1; }
-   _EngineFunctionDefaultArguments( D d, E e )
-      : d( d ),
-        e( e )
-      { mNumDefaultArgs = 2; }
-   _EngineFunctionDefaultArguments( C c, D d, E e )
-      : c( c ),
-        d( d ),
-        e( e )
-      { mNumDefaultArgs = 3; }
-   _EngineFunctionDefaultArguments( B b, C c, D d, E e )
-      : b( b ),
-        c( c ),
-        d( d ),
-        e( e )
-      { mNumDefaultArgs = 4; }
-   _EngineFunctionDefaultArguments( A a, B b, C c, D d, E e )
-      : a( a ),
-        b( b ),
-        c( c ),
-        d( d ),
-        e( e )
-      { mNumDefaultArgs = 5; }
-};
-template< typename A, typename B, typename C, typename D, typename E, typename F >
-struct _EngineFunctionDefaultArguments< void( A, B, C, D, E, F ) > : public EngineFunctionDefaultArguments
-{
-   typename EngineTypeTraits< A >::DefaultArgumentValueStoreType a;
-   typename EngineTypeTraits< B >::DefaultArgumentValueStoreType b;
-   typename EngineTypeTraits< C >::DefaultArgumentValueStoreType c;
-   typename EngineTypeTraits< D >::DefaultArgumentValueStoreType d;
-   typename EngineTypeTraits< E >::DefaultArgumentValueStoreType e;
-   typename EngineTypeTraits< F >::DefaultArgumentValueStoreType f;
+   template<size_t ...I> struct Gens<0, I...>{ typedef Seq<I...> type; };
    
-   _EngineFunctionDefaultArguments()
-      { mNumDefaultArgs = 0; }
-   _EngineFunctionDefaultArguments( F f )
-      : f( f )
-      { mNumDefaultArgs = 1; }
-   _EngineFunctionDefaultArguments( E e, F f )
-      : e( e ),
-        f( f )
-      { mNumDefaultArgs = 2; }
-   _EngineFunctionDefaultArguments( D d, E e, F f )
-      : d( d ),
-        e( e ),
-        f( f )
-      { mNumDefaultArgs = 3; }
-   _EngineFunctionDefaultArguments( C c, D d, E e, F f )
-      : c( c ),
-        d( d ),
-        e( e ),
-        f( f )
-      { mNumDefaultArgs = 4; }
-   _EngineFunctionDefaultArguments( B b, C c, D d, E e, F f )
-      : b( b ),
-        c( c ),
-        d( d ),
-        e( e ),
-        f( f )
-      { mNumDefaultArgs = 5; }
-   _EngineFunctionDefaultArguments( A a, B b, C c, D d, E e, F f )
-      : a( a ),
-        b( b ),
-        c( c ),
-        d( d ),
-        e( e ),
-        f( f )
-      { mNumDefaultArgs = 6; }
-};
-template< typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-struct _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G ) > : public EngineFunctionDefaultArguments
-{
-   typename EngineTypeTraits< A >::DefaultArgumentValueStoreType a;
-   typename EngineTypeTraits< B >::DefaultArgumentValueStoreType b;
-   typename EngineTypeTraits< C >::DefaultArgumentValueStoreType c;
-   typename EngineTypeTraits< D >::DefaultArgumentValueStoreType d;
-   typename EngineTypeTraits< E >::DefaultArgumentValueStoreType e;
-   typename EngineTypeTraits< F >::DefaultArgumentValueStoreType f;
-   typename EngineTypeTraits< G >::DefaultArgumentValueStoreType g;
-   
-   _EngineFunctionDefaultArguments()
-      { mNumDefaultArgs = 0; }
-   _EngineFunctionDefaultArguments( G g )
-      : g( g )
-      { mNumDefaultArgs = 1; }
-   _EngineFunctionDefaultArguments( F f, G g )
-      : f( f ),
-        g( g )
-      { mNumDefaultArgs = 2; }
-   _EngineFunctionDefaultArguments( E e, F f, G g )
-      : e( e ),
-        f( f ),
-        g( g )
-      { mNumDefaultArgs = 3; }
-   _EngineFunctionDefaultArguments( D d, E e, F f, G g )
-      : d( d ),
-        e( e ),
-        f( f ),
-        g( g )
-      { mNumDefaultArgs = 4; }
-   _EngineFunctionDefaultArguments( C c, D d, E e, F f, G g )
-      : c( c ),
-        d( d ),
-        e( e ),
-        f( f ),
-        g( g )
-      { mNumDefaultArgs = 5; }
-   _EngineFunctionDefaultArguments( B b, C c, D d, E e, F f, G g )
-      : b( b ),
-        c( c ),
-        d( d ),
-        e( e ),
-        f( f ),
-        g( g )
-      { mNumDefaultArgs = 6; }
-   _EngineFunctionDefaultArguments( A a, B b, C c, D d, E e, F f, G g )
-      : a( a ),
-        b( b ),
-        c( c ),
-        d( d ),
-        e( e ),
-        f( f ),
-        g( g )
-      { mNumDefaultArgs = 7; }
-};
-template< typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-struct _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H ) > : public EngineFunctionDefaultArguments
-{
-   typename EngineTypeTraits< A >::DefaultArgumentValueStoreType a;
-   typename EngineTypeTraits< B >::DefaultArgumentValueStoreType b;
-   typename EngineTypeTraits< C >::DefaultArgumentValueStoreType c;
-   typename EngineTypeTraits< D >::DefaultArgumentValueStoreType d;
-   typename EngineTypeTraits< E >::DefaultArgumentValueStoreType e;
-   typename EngineTypeTraits< F >::DefaultArgumentValueStoreType f;
-   typename EngineTypeTraits< G >::DefaultArgumentValueStoreType g;
-   typename EngineTypeTraits< H >::DefaultArgumentValueStoreType h;
+   template<typename ...TailTs, size_t ...I>
+   static void copyHelper(std::tuple<DefVST<ArgTs> ...> &args, std::tuple<DefVST<TailTs> ...> &defaultArgs, Seq<I...>)  {
+      std::tie(std::get<I + (sizeof...(ArgTs) - sizeof...(TailTs))>(args)...) = defaultArgs;
+   }
    
-   _EngineFunctionDefaultArguments()
-      { mNumDefaultArgs = 0; }
-   _EngineFunctionDefaultArguments( H h )
-      : h( h )
-      { mNumDefaultArgs = 1; }
-   _EngineFunctionDefaultArguments( G g, H h )
-      : g( g ),
-        h( h )
-      { mNumDefaultArgs = 2; }
-   _EngineFunctionDefaultArguments( F f, G g, H h )
-      : f( f ),
-        g( g ),
-        h( h )
-      { mNumDefaultArgs = 3; }
-   _EngineFunctionDefaultArguments( E e, F f, G g, H h )
-      : e( e ),
-        f( f ),
-        g( g ),
-        h( h )
-      { mNumDefaultArgs = 4; }
-   _EngineFunctionDefaultArguments( D d, E e, F f, G g, H h )
-      : d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h )
-      { mNumDefaultArgs = 5; }
-   _EngineFunctionDefaultArguments( C c, D d, E e, F f, G g, H h )
-      : c( c ),
-        d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h )
-      { mNumDefaultArgs = 6; }
-   _EngineFunctionDefaultArguments( B b, C c, D d, E e, F f, G g, H h )
-      : b( b ),
-        c( c ),
-        d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h )
-      { mNumDefaultArgs = 7; }
-   _EngineFunctionDefaultArguments( A a, B b, C c, D d, E e, F f, G g, H h )
-      : a( a ),
-        b( b ),
-        c( c ),
-        d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h )
-      { mNumDefaultArgs = 8; }
-};
-template< typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
-struct _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H, I ) > : public EngineFunctionDefaultArguments
-{
-   typename EngineTypeTraits< A >::DefaultArgumentValueStoreType a;
-   typename EngineTypeTraits< B >::DefaultArgumentValueStoreType b;
-   typename EngineTypeTraits< C >::DefaultArgumentValueStoreType c;
-   typename EngineTypeTraits< D >::DefaultArgumentValueStoreType d;
-   typename EngineTypeTraits< E >::DefaultArgumentValueStoreType e;
-   typename EngineTypeTraits< F >::DefaultArgumentValueStoreType f;
-   typename EngineTypeTraits< G >::DefaultArgumentValueStoreType g;
-   typename EngineTypeTraits< H >::DefaultArgumentValueStoreType h;
-   typename EngineTypeTraits< I >::DefaultArgumentValueStoreType i;
+   template<typename ...TailTs> using MaybeSelfEnabled = typename std::enable_if<sizeof...(TailTs) <= sizeof...(ArgTs), decltype(mArgs)>::type;
    
-   _EngineFunctionDefaultArguments()
-      { mNumDefaultArgs = 0; }
-   _EngineFunctionDefaultArguments( I i )
-      : i( i )
-      { mNumDefaultArgs = 1; }
-   _EngineFunctionDefaultArguments( H h, I i )
-      : h( h ),
-        i( i )
-      { mNumDefaultArgs = 2; }
-   _EngineFunctionDefaultArguments( G g, H h, I i )
-      : g( g ),
-        h( h ),
-        i( i )
-      { mNumDefaultArgs = 3; }
-   _EngineFunctionDefaultArguments( F f, G g, H h, I i )
-      : f( f ),
-        g( g ),
-        h( h ),
-        i( i )
-      { mNumDefaultArgs = 4; }
-   _EngineFunctionDefaultArguments( E e, F f, G g, H h, I i )
-      : e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i )
-      { mNumDefaultArgs = 5; }
-   _EngineFunctionDefaultArguments( D d, E e, F f, G g, H h, I i )
-      : d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i )
-      { mNumDefaultArgs = 6; }
-   _EngineFunctionDefaultArguments( C c, D d, E e, F f, G g, H h, I i )
-      : c( c ),
-        d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i )
-      { mNumDefaultArgs = 7; }
-   _EngineFunctionDefaultArguments( B b, C c, D d, E e, F f, G g, H h, I i )
-      : b( b ),
-        c( c ),
-        d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i )
-      { mNumDefaultArgs = 8; }
-   _EngineFunctionDefaultArguments( A a, B b, C c, D d, E e, F f, G g, H h, I i )
-      : a( a ),
-        b( b ),
-        c( c ),
-        d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i )
-      { mNumDefaultArgs = 9; }
-};
-template< typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J >
-struct _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H, I, J ) > : public EngineFunctionDefaultArguments
-{
-   typename EngineTypeTraits< A >::DefaultArgumentValueStoreType a;
-   typename EngineTypeTraits< B >::DefaultArgumentValueStoreType b;
-   typename EngineTypeTraits< C >::DefaultArgumentValueStoreType c;
-   typename EngineTypeTraits< D >::DefaultArgumentValueStoreType d;
-   typename EngineTypeTraits< E >::DefaultArgumentValueStoreType e;
-   typename EngineTypeTraits< F >::DefaultArgumentValueStoreType f;
-   typename EngineTypeTraits< G >::DefaultArgumentValueStoreType g;
-   typename EngineTypeTraits< H >::DefaultArgumentValueStoreType h;
-   typename EngineTypeTraits< I >::DefaultArgumentValueStoreType i;
-   typename EngineTypeTraits< J >::DefaultArgumentValueStoreType j;
+   template<typename ...TailTs> static MaybeSelfEnabled<TailTs...> tailInit(TailTs ...tail) {
+      std::tuple<DefVST<ArgTs>...> argsT;
+      std::tuple<DefVST<TailTs>...> tailT = std::make_tuple(tail...);
+      SelfType::copyHelper<TailTs...>(argsT, tailT, typename Gens<sizeof...(TailTs)>::type());
+      return argsT;
+   };
    
-   _EngineFunctionDefaultArguments()
-      { mNumDefaultArgs = 0; }
-   _EngineFunctionDefaultArguments( J j )
-      : j( j )
-      { mNumDefaultArgs = 1; }
-   _EngineFunctionDefaultArguments( I i, J j )
-      : i( i ),
-        j( j )
-      { mNumDefaultArgs = 2; }
-   _EngineFunctionDefaultArguments( H h, I i, J j )
-      : h( h ),
-        i( i ),
-        j( j )
-      { mNumDefaultArgs = 3; }
-   _EngineFunctionDefaultArguments( G g, H h, I i, J j )
-      : g( g ),
-        h( h ),
-        i( i ),
-        j( j )
-      { mNumDefaultArgs = 4; }
-   _EngineFunctionDefaultArguments( F f, G g, H h, I i, J j )
-      : f( f ),
-        g( g ),
-        h( h ),
-        i( i ),
-        j( j )
-      { mNumDefaultArgs = 5; }
-   _EngineFunctionDefaultArguments( E e, F f, G g, H h, I i, J j )
-      : e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i ),
-        j( j )
-      { mNumDefaultArgs = 6; }
-   _EngineFunctionDefaultArguments( D d, E e, F f, G g, H h, I i, J j )
-      : d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i ),
-        j( j )
-      { mNumDefaultArgs = 7; }
-   _EngineFunctionDefaultArguments( C c, D d, E e, F f, G g, H h, I i, J j )
-      : c( c ),
-        d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i ),
-        j( j )
-      { mNumDefaultArgs = 8; }
-   _EngineFunctionDefaultArguments( B b, C c, D d, E e, F f, G g, H h, I i, J j )
-      : b( b ),
-        c( c ),
-        d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i ),
-        j( j )
-      { mNumDefaultArgs = 9; }
-   _EngineFunctionDefaultArguments( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j )
-      : a( a ),
-        b( b ),
-        c( c ),
-        d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i ),
-        j( j )
-      { mNumDefaultArgs = 10; }
-};
-template< typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K >
-struct _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H, I, J, K ) > : public EngineFunctionDefaultArguments
-{
-   typename EngineTypeTraits< A >::DefaultArgumentValueStoreType a;
-   typename EngineTypeTraits< B >::DefaultArgumentValueStoreType b;
-   typename EngineTypeTraits< C >::DefaultArgumentValueStoreType c;
-   typename EngineTypeTraits< D >::DefaultArgumentValueStoreType d;
-   typename EngineTypeTraits< E >::DefaultArgumentValueStoreType e;
-   typename EngineTypeTraits< F >::DefaultArgumentValueStoreType f;
-   typename EngineTypeTraits< G >::DefaultArgumentValueStoreType g;
-   typename EngineTypeTraits< H >::DefaultArgumentValueStoreType h;
-   typename EngineTypeTraits< I >::DefaultArgumentValueStoreType i;
-   typename EngineTypeTraits< J >::DefaultArgumentValueStoreType j;
-   typename EngineTypeTraits< K >::DefaultArgumentValueStoreType k;
-
-   _EngineFunctionDefaultArguments()
-      { mNumDefaultArgs = 0; }
-   _EngineFunctionDefaultArguments( K k )
-      : k( k )
-      { mNumDefaultArgs = 1; }
-   _EngineFunctionDefaultArguments( J j, K k )
-      : j( j ),
-        k( k )
-      { mNumDefaultArgs = 2; }
-   _EngineFunctionDefaultArguments( I i, J j, K k )
-      : i( i ),
-        j( j ),
-        k( k )
-      { mNumDefaultArgs = 3; }
-   _EngineFunctionDefaultArguments( H h, I i, J j, K k )
-      : h( h ),
-        i( i ),
-        j( j ),
-        k( k )
-      { mNumDefaultArgs = 4; }
-   _EngineFunctionDefaultArguments( G g, H h, I i, J j, K k )
-      : g( g ),
-        h( h ),
-        i( i ),
-        j( j ),
-        k( k )
-      { mNumDefaultArgs = 5; }
-   _EngineFunctionDefaultArguments( F f, G g, H h, I i, J j, K k )
-      : f( f ),
-        g( g ),
-        h( h ),
-        i( i ),
-        j( j ),
-        k( k )
-      { mNumDefaultArgs = 6; }
-   _EngineFunctionDefaultArguments( E e, F f, G g, H h, I i, J j, K k )
-      : e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i ),
-        j( j ),
-        k( k )
-      { mNumDefaultArgs = 7; }
-   _EngineFunctionDefaultArguments( D d, E e, F f, G g, H h, I i, J j, K k )
-      : d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i ),
-        j( j ),
-        k( k )
-      { mNumDefaultArgs = 8; }
-   _EngineFunctionDefaultArguments( C c, D d, E e, F f, G g, H h, I i, J j, K k )
-      : c( c ),
-        d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i ),
-        j( j ),
-        k( k )
-      { mNumDefaultArgs = 9; }
-   _EngineFunctionDefaultArguments( B b, C c, D d, E e, F f, G g, H h, I i, J j, K k )
-      : b( b ),
-        c( c ),
-        d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i ),
-        j( j ),
-        k( k )
-      { mNumDefaultArgs = 10; }
-   _EngineFunctionDefaultArguments( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k )
-      : a( a ),
-        b( b ),
-        c( c ),
-        d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i ),
-        j( j ),
-        k( k )
-      { mNumDefaultArgs = 11; }
-};
-template< typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L >
-struct _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H, I, J, K, L ) > : public EngineFunctionDefaultArguments
-{
-   typename EngineTypeTraits< A >::DefaultArgumentValueStoreType a;
-   typename EngineTypeTraits< B >::DefaultArgumentValueStoreType b;
-   typename EngineTypeTraits< C >::DefaultArgumentValueStoreType c;
-   typename EngineTypeTraits< D >::DefaultArgumentValueStoreType d;
-   typename EngineTypeTraits< E >::DefaultArgumentValueStoreType e;
-   typename EngineTypeTraits< F >::DefaultArgumentValueStoreType f;
-   typename EngineTypeTraits< G >::DefaultArgumentValueStoreType g;
-   typename EngineTypeTraits< H >::DefaultArgumentValueStoreType h;
-   typename EngineTypeTraits< I >::DefaultArgumentValueStoreType i;
-   typename EngineTypeTraits< J >::DefaultArgumentValueStoreType j;
-   typename EngineTypeTraits< K >::DefaultArgumentValueStoreType k;
-   typename EngineTypeTraits< L >::DefaultArgumentValueStoreType l;
-
-   _EngineFunctionDefaultArguments()
-      { mNumDefaultArgs = 0; }
-   _EngineFunctionDefaultArguments( L l )
-      : l( l )
-      { mNumDefaultArgs = 1; }
-   _EngineFunctionDefaultArguments( K k, L l )
-      : k( k ),
-        l( l )
-      { mNumDefaultArgs = 2; }
-   _EngineFunctionDefaultArguments( J j, K k, L l )
-      : j( j ),
-        k( k ),
-        l( l )
-      { mNumDefaultArgs = 3; }
-   _EngineFunctionDefaultArguments( I i, J j, K k, L l )
-      : i( i ),
-        j( j ),
-        k( k ),
-        l( l )
-      { mNumDefaultArgs = 4; }
-   _EngineFunctionDefaultArguments( H h, I i, J j, K k, L l )
-      : h( h ),
-        i( i ),
-        j( j ),
-        k( k ),
-        l( l )
-      { mNumDefaultArgs = 5; }
-   _EngineFunctionDefaultArguments( G g, H h, I i, J j, K k, L l )
-      : g( g ),
-        h( h ),
-        i( i ),
-        j( j ),
-        k( k ),
-        l( l )
-      { mNumDefaultArgs = 6; }
-   _EngineFunctionDefaultArguments( F f, G g, H h, I i, J j, K k, L l )
-      : f( f ),
-        g( g ),
-        h( h ),
-        i( i ),
-        j( j ),
-        k( k ),
-        l( l )
-      { mNumDefaultArgs = 7; }
-   _EngineFunctionDefaultArguments( E e, F f, G g, H h, I i, J j, K k, L l )
-      : e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i ),
-        j( j ),
-        k( k ),
-        l( l )
-      { mNumDefaultArgs = 8; }
-   _EngineFunctionDefaultArguments( D d, E e, F f, G g, H h, I i, J j, K k, L l )
-      : d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i ),
-        j( j ),
-        k( k ),
-        l( l )
-      { mNumDefaultArgs = 9; }
-   _EngineFunctionDefaultArguments( C c, D d, E e, F f, G g, H h, I i, J j, K k, L l )
-      : c( c ),
-        d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i ),
-        j( j ),
-        k( k ),
-        l( l )
-      { mNumDefaultArgs = 10; }
-   _EngineFunctionDefaultArguments( B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l )
-      : b( b ),
-        c( c ),
-        d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i ),
-        j( j ),
-        k( k ),
-        l( l )
-      { mNumDefaultArgs = 11; }
-   _EngineFunctionDefaultArguments( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l )
-      : a( a ),
-        b( b ),
-        c( c ),
-        d( d ),
-        e( e ),
-        f( f ),
-        g( g ),
-        h( h ),
-        i( i ),
-        j( j ),
-        k( k ),
-        l( l )
-      { mNumDefaultArgs = 12; }
+public:
+   template<typename ...TailTs> _EngineFunctionDefaultArguments(TailTs ...tail)
+   : EngineFunctionDefaultArguments({sizeof...(TailTs)}), mArgs(SelfType::tailInit(tail...))
+   {}
 };
 
 #pragma pack( pop )

Engine/source/console/enginePrimitives.h

@@ -41,6 +41,8 @@ DECLARE_PRIMITIVE_R(S32);
 DECLARE_PRIMITIVE_R(U32);
 DECLARE_PRIMITIVE_R(F32);
 DECLARE_PRIMITIVE_R(F64);
+DECLARE_PRIMITIVE_R(U64);
+DECLARE_PRIMITIVE_R(S64);
 DECLARE_PRIMITIVE_R(void*);
 
 

Engine/source/console/engineTypeInfo.h

@@ -648,395 +648,33 @@ template< typename T > const EngineFunctionTypeInfo< T > _EngineFunctionTypeTrai
 //    Function Argument Type Infos.
 //--------------------------------------------------------------------------
 
-template< typename R >
-struct _EngineArgumentTypeTable< R() > : public EngineArgumentTypeTable
-{
-   static const U32 NUM_ARGUMENTS = 0;
-   static const bool VARIADIC = false;
-   static const EngineTypeInfo* const RETURN;
-#ifdef TORQUE_COMPILER_GCC
-   static const EngineTypeInfo* const ARGS[ 0 ];
-#else
-   static const EngineTypeInfo* const ARGS[ 1 ];
-#endif
 
-   _EngineArgumentTypeTable()
-      : EngineArgumentTypeTable( TYPE< typename EngineTypeTraits< R >::Type >(), NUM_ARGUMENTS, ARGS ) {}
-};
-template< typename R > const EngineTypeInfo* const _EngineArgumentTypeTable< R() >::RETURN = TYPE< typename EngineTypeTraits< R >::Type >();
-#ifdef TORQUE_COMPILER_GCC
-template< typename R > const EngineTypeInfo* const _EngineArgumentTypeTable< R() >::ARGS[ 0 ] = {};
+#ifdef TORQUE_COMILER_GCC
+#define ARGS_SIZE_SAFE(wanted) (wanted)
 #else
-template< typename R > const EngineTypeInfo* const _EngineArgumentTypeTable< R() >::ARGS[ 1 ] = {};
+#define ARGS_SIZE_SAFE(wanted) (((wanted) < 1) ? 1 : (wanted))
 #endif
-template< typename R >
-struct _EngineArgumentTypeTable< R( ... ) > : public _EngineArgumentTypeTable< R() >
-{
-   static const bool VARIADIC = true;
-   _EngineArgumentTypeTable() {}
-};
-
-template< typename R, typename A >
-struct _EngineArgumentTypeTable< R( A ) > : public EngineArgumentTypeTable
-{
-   static const U32 NUM_ARGUMENTS = 1;
-   static const bool VARIADIC = false;
-   static const EngineTypeInfo* const RETURN;
-   static const EngineTypeInfo* const ARGS[ 1 ];
-
-   _EngineArgumentTypeTable()
-      : EngineArgumentTypeTable( TYPE< typename EngineTypeTraits< R >::Type >(), NUM_ARGUMENTS, ARGS ) {}
-};
-template< typename R, typename A >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A ) >::RETURN = TYPE< typename EngineTypeTraits< R >::Type >();
-template< typename R, typename A >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A ) >::ARGS[ 1 ] =
-{
-   TYPE< typename EngineTypeTraits< A >::Type >()
-};
-template< typename R, typename A >
-struct _EngineArgumentTypeTable< R( A, ... ) > : public _EngineArgumentTypeTable< R( A ) >
-{
-   static const bool VARIADIC = true;
-   _EngineArgumentTypeTable() {}
-};
-
-template< typename R, typename A, typename B >
-struct _EngineArgumentTypeTable< R( A, B ) > : public EngineArgumentTypeTable
-{
-   static const U32 NUM_ARGUMENTS = 2;
-   static const bool VARIADIC = false;
-   static const EngineTypeInfo* const RETURN;
-   static const EngineTypeInfo* const ARGS[ 2 ];
-
-   _EngineArgumentTypeTable()
-      : EngineArgumentTypeTable( TYPE< typename EngineTypeTraits< R >::Type >(), NUM_ARGUMENTS, ARGS ) {}
-};
-template< typename R, typename A, typename B >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B ) >::RETURN = TYPE< typename EngineTypeTraits< R >::Type >();
-template< typename R, typename A, typename B >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B ) >::ARGS[ 2 ] =
-{
-   TYPE< typename EngineTypeTraits< A >::Type >(),
-   TYPE< typename EngineTypeTraits< B >::Type >()
-};
-template< typename R, typename A, typename B >
-struct _EngineArgumentTypeTable< R( A, B, ... ) > : public _EngineArgumentTypeTable< R( A, B ) >
-{
-   static const bool VARIADIC = true;
-   _EngineArgumentTypeTable() {}
-};
-
-template< typename R, typename A, typename B, typename C >
-struct _EngineArgumentTypeTable< R( A, B, C ) > : public EngineArgumentTypeTable
-{
-   static const U32 NUM_ARGUMENTS = 3;
-   static const bool VARIADIC = false;
-   static const EngineTypeInfo* const RETURN;
-   static const EngineTypeInfo* const ARGS[ 3 ];
-
-   _EngineArgumentTypeTable()
-      : EngineArgumentTypeTable( TYPE< typename EngineTypeTraits< R >::Type >(), NUM_ARGUMENTS, ARGS ) {}
-};
-template< typename R, typename A, typename B, typename C >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C ) >::RETURN = TYPE< typename EngineTypeTraits< R >::Type >();
-template< typename R, typename A, typename B, typename C >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C ) >::ARGS[ 3 ] =
-{
-   TYPE< typename EngineTypeTraits< A >::Type >(),
-   TYPE< typename EngineTypeTraits< B >::Type >(),
-   TYPE< typename EngineTypeTraits< C >::Type >()
-};
-template< typename R, typename A, typename B, typename C >
-struct _EngineArgumentTypeTable< R( A, B, C, ... ) > : public _EngineArgumentTypeTable< R( A, B, C ) >
-{
-   static const bool VARIADIC = true;
-   _EngineArgumentTypeTable() {}
-};
-
-template< typename R, typename A, typename B, typename C, typename D >
-struct _EngineArgumentTypeTable< R( A, B, C, D ) > : public EngineArgumentTypeTable
-{
-   static const U32 NUM_ARGUMENTS = 4;
-   static const bool VARIADIC = false;
-   static const EngineTypeInfo* const RETURN;
-   static const EngineTypeInfo* const ARGS[ 4 ];
-
-   _EngineArgumentTypeTable()
-      : EngineArgumentTypeTable( TYPE< typename EngineTypeTraits< R >::Type >(), NUM_ARGUMENTS, ARGS ) {}
-};
-template< typename R, typename A, typename B, typename C, typename D >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C, D ) >::RETURN = TYPE< typename EngineTypeTraits< R >::Type >();
-template< typename R, typename A, typename B, typename C, typename D >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C, D ) >::ARGS[ 4 ] =
-{
-   TYPE< typename EngineTypeTraits< A >::Type >(),
-   TYPE< typename EngineTypeTraits< B >::Type >(),
-   TYPE< typename EngineTypeTraits< C >::Type >(),
-   TYPE< typename EngineTypeTraits< D >::Type >()
-};
-template< typename R, typename A, typename B, typename C, typename D >
-struct _EngineArgumentTypeTable< R( A, B, C, D, ... ) > : public _EngineArgumentTypeTable< R( A, B, C, D ) >
-{
-   static const bool VARIADIC = true;
-   _EngineArgumentTypeTable() {}
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E >
-struct _EngineArgumentTypeTable< R( A, B, C, D, E ) > : public EngineArgumentTypeTable
-{
-   static const U32 NUM_ARGUMENTS = 5;
-   static const bool VARIADIC = false;
-   static const EngineTypeInfo* const RETURN;
-   static const EngineTypeInfo* const ARGS[ 5 ];
-
-   _EngineArgumentTypeTable()
-      : EngineArgumentTypeTable( TYPE< typename EngineTypeTraits< R >::Type >(), NUM_ARGUMENTS, ARGS ) {}
-};
-template< typename R, typename A, typename B, typename C, typename D, typename E >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C, D, E ) >::RETURN = TYPE< typename EngineTypeTraits< R >::Type >();
-template< typename R, typename A, typename B, typename C, typename D, typename E >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C, D, E ) >::ARGS[ 5 ] =
-{
-   TYPE< typename EngineTypeTraits< A >::Type >(),
-   TYPE< typename EngineTypeTraits< B >::Type >(),
-   TYPE< typename EngineTypeTraits< C >::Type >(),
-   TYPE< typename EngineTypeTraits< D >::Type >(),
-   TYPE< typename EngineTypeTraits< E >::Type >()
-};
-template< typename R, typename A, typename B, typename C, typename D, typename E >
-struct _EngineArgumentTypeTable< R( A, B, C, D, E, ... ) > : public _EngineArgumentTypeTable< R( A, B, C, D, E ) >
-{
-   static const bool VARIADIC = true;
-   _EngineArgumentTypeTable() {}
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F >
-struct _EngineArgumentTypeTable< R( A, B, C, D, E, F ) > : public EngineArgumentTypeTable
-{
-   static const U32 NUM_ARGUMENTS = 6;
-   static const bool VARIADIC = false;
-   static const EngineTypeInfo* const RETURN;
-   static const EngineTypeInfo* const ARGS[ 6 ];
-
-   _EngineArgumentTypeTable()
-      : EngineArgumentTypeTable( TYPE< typename EngineTypeTraits< R >::Type >(), NUM_ARGUMENTS, ARGS ) {}
-};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C, D, E, F ) >::RETURN = TYPE< typename EngineTypeTraits< R >::Type >();
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C, D, E, F ) >::ARGS[ 6 ] =
-{
-   TYPE< typename EngineTypeTraits< A >::Type >(),
-   TYPE< typename EngineTypeTraits< B >::Type >(),
-   TYPE< typename EngineTypeTraits< C >::Type >(),
-   TYPE< typename EngineTypeTraits< D >::Type >(),
-   TYPE< typename EngineTypeTraits< E >::Type >(),
-   TYPE< typename EngineTypeTraits< F >::Type >()
-};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F >
-struct _EngineArgumentTypeTable< R( A, B, C, D, E, F, ... ) > : public _EngineArgumentTypeTable< R( A, B, C, D, E, F ) >
-{
-   static const bool VARIADIC = true;
-   _EngineArgumentTypeTable() {}
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-struct _EngineArgumentTypeTable< R( A, B, C, D, E, F, G ) > : public EngineArgumentTypeTable
-{
-   static const U32 NUM_ARGUMENTS = 7;
-   static const bool VARIADIC = false;
-   static const EngineTypeInfo* const RETURN;
-   static const EngineTypeInfo* const ARGS[ 7 ];
-
-   _EngineArgumentTypeTable()
-      : EngineArgumentTypeTable( TYPE< typename EngineTypeTraits< R >::Type >(), NUM_ARGUMENTS, ARGS ) {}
-};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C, D, E, F, G ) >::RETURN = TYPE< typename EngineTypeTraits< R >::Type >();
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C, D, E, F, G ) >::ARGS[ 7 ] =
-{
-   TYPE< typename EngineTypeTraits< A >::Type >(),
-   TYPE< typename EngineTypeTraits< B >::Type >(),
-   TYPE< typename EngineTypeTraits< C >::Type >(),
-   TYPE< typename EngineTypeTraits< D >::Type >(),
-   TYPE< typename EngineTypeTraits< E >::Type >(),
-   TYPE< typename EngineTypeTraits< F >::Type >(),
-   TYPE< typename EngineTypeTraits< G >::Type >()
-};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-struct _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, ... ) > : public _EngineArgumentTypeTable< R( A, B, C, D, E, F, G ) >
-{
-   static const bool VARIADIC = true;
-   _EngineArgumentTypeTable() {}
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-struct _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H ) > : public EngineArgumentTypeTable
-{
-   static const U32 NUM_ARGUMENTS = 8;
-   static const bool VARIADIC = false;
-   static const EngineTypeInfo* const RETURN;
-   static const EngineTypeInfo* const ARGS[ 8 ];
-
-   _EngineArgumentTypeTable()
-      : EngineArgumentTypeTable( TYPE< typename EngineTypeTraits< R >::Type >(), NUM_ARGUMENTS, ARGS ) {}
-};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H ) >::RETURN = TYPE< typename EngineTypeTraits< R >::Type >();
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H ) >::ARGS[ 8 ] =
-{
-   TYPE< typename EngineTypeTraits< A >::Type >(),
-   TYPE< typename EngineTypeTraits< B >::Type >(),
-   TYPE< typename EngineTypeTraits< C >::Type >(),
-   TYPE< typename EngineTypeTraits< D >::Type >(),
-   TYPE< typename EngineTypeTraits< E >::Type >(),
-   TYPE< typename EngineTypeTraits< F >::Type >(),
-   TYPE< typename EngineTypeTraits< G >::Type >(),
-   TYPE< typename EngineTypeTraits< H >::Type >()
-};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-struct _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, ... ) > : public _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H ) >
-{
-   static const bool VARIADIC = true;
-   _EngineArgumentTypeTable() {}
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
-struct _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I ) > : public EngineArgumentTypeTable
-{
-   static const U32 NUM_ARGUMENTS = 9;
-   static const bool VARIADIC = false;
-   static const EngineTypeInfo* const RETURN;
-   static const EngineTypeInfo* const ARGS[ 9 ];
-
-   _EngineArgumentTypeTable()
-      : EngineArgumentTypeTable( TYPE< typename EngineTypeTraits< R >::Type >(), NUM_ARGUMENTS, ARGS ) {}
-};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I ) >::RETURN = TYPE< typename EngineTypeTraits< R >::Type >();
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I ) >::ARGS[ 9 ] =
-{
-   TYPE< typename EngineTypeTraits< A >::Type >(),
-   TYPE< typename EngineTypeTraits< B >::Type >(),
-   TYPE< typename EngineTypeTraits< C >::Type >(),
-   TYPE< typename EngineTypeTraits< D >::Type >(),
-   TYPE< typename EngineTypeTraits< E >::Type >(),
-   TYPE< typename EngineTypeTraits< F >::Type >(),
-   TYPE< typename EngineTypeTraits< G >::Type >(),
-   TYPE< typename EngineTypeTraits< H >::Type >(),
-   TYPE< typename EngineTypeTraits< I >::Type >()
-};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
-struct _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, ... ) > : public _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I ) >
-{
-   static const bool VARIADIC = true;
-   _EngineArgumentTypeTable() {}
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J >
-struct _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J ) > : public EngineArgumentTypeTable
-{
-   static const U32 NUM_ARGUMENTS = 10;
-   static const bool VARIADIC = false;
-   static const EngineTypeInfo* const RETURN;
-   static const EngineTypeInfo* const ARGS[ 10 ];
-
-   _EngineArgumentTypeTable()
-      : EngineArgumentTypeTable( TYPE< typename EngineTypeTraits< R >::Type >(), NUM_ARGUMENTS, ARGS ) {}
-};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J ) >::RETURN = TYPE< typename EngineTypeTraits< R >::Type >();
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J ) >::ARGS[ 10 ] =
-{
-   TYPE< typename EngineTypeTraits< A >::Type >(),
-   TYPE< typename EngineTypeTraits< B >::Type >(),
-   TYPE< typename EngineTypeTraits< C >::Type >(),
-   TYPE< typename EngineTypeTraits< D >::Type >(),
-   TYPE< typename EngineTypeTraits< E >::Type >(),
-   TYPE< typename EngineTypeTraits< F >::Type >(),
-   TYPE< typename EngineTypeTraits< G >::Type >(),
-   TYPE< typename EngineTypeTraits< H >::Type >(),
-   TYPE< typename EngineTypeTraits< I >::Type >(),
-   TYPE< typename EngineTypeTraits< J >::Type >()
-};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J >
-struct _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J, ... ) > : public _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J ) >
-{
-   static const bool VARIADIC = true;
-   _EngineArgumentTypeTable() {}
-};
-
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K >
-struct _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J, K ) > : public EngineArgumentTypeTable
-{
-   static const U32 NUM_ARGUMENTS = 11;
-   static const bool VARIADIC = false;
-   static const EngineTypeInfo* const RETURN;
-   static const EngineTypeInfo* const ARGS[ 11 ];
-
-   _EngineArgumentTypeTable()
-      : EngineArgumentTypeTable( TYPE< typename EngineTypeTraits< R >::Type >(), NUM_ARGUMENTS, ARGS ) {}
-};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J, K ) >::RETURN = TYPE< typename EngineTypeTraits< R >::Type >();
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J, K ) >::ARGS[ 11 ] =
-{
-   TYPE< typename EngineTypeTraits< A >::Type >(),
-   TYPE< typename EngineTypeTraits< B >::Type >(),
-   TYPE< typename EngineTypeTraits< C >::Type >(),
-   TYPE< typename EngineTypeTraits< D >::Type >(),
-   TYPE< typename EngineTypeTraits< E >::Type >(),
-   TYPE< typename EngineTypeTraits< F >::Type >(),
-   TYPE< typename EngineTypeTraits< G >::Type >(),
-   TYPE< typename EngineTypeTraits< H >::Type >(),
-   TYPE< typename EngineTypeTraits< I >::Type >(),
-   TYPE< typename EngineTypeTraits< J >::Type >(),
-   TYPE< typename EngineTypeTraits< K >::Type >()
-};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K >
-struct _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J, K, ... ) > : public _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J, K ) >
-{
-   static const bool VARIADIC = true;
-   _EngineArgumentTypeTable() {}
-};
 
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L >
-struct _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J, K, L ) > : public EngineArgumentTypeTable
+template< typename R, typename ...ArgTs >
+struct _EngineArgumentTypeTable< R( ArgTs ... ) > : public EngineArgumentTypeTable
 {
-   static const U32 NUM_ARGUMENTS = 12;
+   static const U32 NUM_ARGUMENTS = sizeof...(ArgTs);
    static const bool VARIADIC = false;
    static const EngineTypeInfo* const RETURN;
-   static const EngineTypeInfo* const ARGS[ 12 ];
+   static const EngineTypeInfo* const ARGS[ ARGS_SIZE_SAFE(sizeof...(ArgTs)) ];
 
    _EngineArgumentTypeTable()
       : EngineArgumentTypeTable( TYPE< typename EngineTypeTraits< R >::Type >(), NUM_ARGUMENTS, ARGS ) {}
 };
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J, K, L ) >::RETURN = TYPE< typename EngineTypeTraits< R >::Type >();
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L >
-const EngineTypeInfo* const _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J, K, L ) >::ARGS[ 12 ] =
+template< typename R, typename ...ArgTs >
+const EngineTypeInfo* const _EngineArgumentTypeTable< R( ArgTs ... ) >::RETURN = TYPE< typename EngineTypeTraits< R >::Type >();
+template< typename R, typename ...ArgTs >
+const EngineTypeInfo* const _EngineArgumentTypeTable< R( ArgTs ... ) >::ARGS[ ARGS_SIZE_SAFE(sizeof...(ArgTs)) ] =
 {
-   TYPE< typename EngineTypeTraits< A >::Type >(),
-   TYPE< typename EngineTypeTraits< B >::Type >(),
-   TYPE< typename EngineTypeTraits< C >::Type >(),
-   TYPE< typename EngineTypeTraits< D >::Type >(),
-   TYPE< typename EngineTypeTraits< E >::Type >(),
-   TYPE< typename EngineTypeTraits< F >::Type >(),
-   TYPE< typename EngineTypeTraits< G >::Type >(),
-   TYPE< typename EngineTypeTraits< H >::Type >(),
-   TYPE< typename EngineTypeTraits< I >::Type >(),
-   TYPE< typename EngineTypeTraits< J >::Type >(),
-   TYPE< typename EngineTypeTraits< K >::Type >(),
-   TYPE< typename EngineTypeTraits< L >::Type >()
+   TYPE< typename EngineTypeTraits< ArgTs >::Type >() ...
 };
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L >
-struct _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J, K, L, ... ) > : public _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J, K, L ) >
+template< typename R, typename ... ArgTs >
+struct _EngineArgumentTypeTable< R( ArgTs ..., ... ) > : public _EngineArgumentTypeTable< R( ArgTs ... ) >
 {
    static const bool VARIADIC = true;
    _EngineArgumentTypeTable() {}

Engine/source/console/engineTypes.h

@@ -284,58 +284,10 @@ template< typename T > const EngineTypeInfo* const _EngineFunctionTypeTraits< T
 // are not guaranteed to be any meaningful value or base types to the engine type system.
 #define T( x ) typename EngineTypeTraits< x >::ValueType
 
-template< typename R >
-struct _EngineTypeTraits< R() > : public _EngineFunctionTypeTraits< T( R )() > {};
-template< typename R >
-struct _EngineTypeTraits< R( ... ) > : public _EngineFunctionTypeTraits< T( R )( ... ) > {};
-template< typename R, typename A >
-struct _EngineTypeTraits< R( A ) > : public _EngineFunctionTypeTraits< T( R )( T( A ) ) > {};
-template< typename R, typename A >
-struct _EngineTypeTraits< R( A, ... ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), ... ) > {};
-template< typename R, typename A, typename B >
-struct _EngineTypeTraits< R( A, B ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ) ) > {};
-template< typename R, typename A, typename B >
-struct _EngineTypeTraits< R( A, B, ... ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), ... ) > {};
-template< typename R, typename A, typename B, typename C >
-struct _EngineTypeTraits< R( A, B, C ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ) ) > {};
-template< typename R, typename A, typename B, typename C >
-struct _EngineTypeTraits< R( A, B, C, ... ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), ... ) > {};
-template< typename R, typename A, typename B, typename C, typename D >
-struct _EngineTypeTraits< R( A, B, C, D ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), T( D ) ) > {};
-template< typename R, typename A, typename B, typename C, typename D >
-struct _EngineTypeTraits< R( A, B, C, D, ... ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), T( D ), ... ) > {};
-template< typename R, typename A, typename B, typename C, typename D, typename E >
-struct _EngineTypeTraits< R( A, B, C, D, E ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), T( D ), T( E ) ) > {};
-template< typename R, typename A, typename B, typename C, typename D, typename E >
-struct _EngineTypeTraits< R( A, B, C, D, E, ... ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), T( D ), T( E ), ... ) > {};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F >
-struct _EngineTypeTraits< R( A, B, C, D, E, F ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), T( D ), T( E ), T( F ) ) > {};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F >
-struct _EngineTypeTraits< R( A, B, C, D, E, F, ... ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), T( D ), T( E ), T( F ), ... ) > {};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-struct _EngineTypeTraits< R( A, B, C, D, E, F, G ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), T( D ), T( E ), T( F ), T( G ) ) > {};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-struct _EngineTypeTraits< R( A, B, C, D, E, F, G, ... ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), T( D ), T( E ), T( F ), T( G ), ... ) > {};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-struct _EngineTypeTraits< R( A, B, C, D, E, F, G, H ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), T( D ), T( E ), T( F ), T( G ), T( H ) ) > {};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-struct _EngineTypeTraits< R( A, B, C, D, E, F, G, H, ... ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), T( D ), T( E ), T( F ), T( G ), T( H ), ... ) > {};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
-struct _EngineTypeTraits< R( A, B, C, D, E, F, G, H, I ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), T( D ), T( E ), T( F ), T( G ), T( H ), T( I ) ) > {};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
-struct _EngineTypeTraits< R( A, B, C, D, E, F, G, H, I, ... ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), T( D ), T( E ), T( F ), T( G ), T( H ), T( I ), ... ) > {};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J >
-struct _EngineTypeTraits< R( A, B, C, D, E, F, G, H, I, J ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), T( D ), T( E ), T( F ), T( G ), T( H ), T( I ), T( J ) ) > {};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J >
-struct _EngineTypeTraits< R( A, B, C, D, E, F, G, H, I, J, ... ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), T( D ), T( E ), T( F ), T( G ), T( H ), T( I ), T( J ), ... ) > {};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K >
-struct _EngineTypeTraits< R( A, B, C, D, E, F, G, H, I, J, K ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), T( D ), T( E ), T( F ), T( G ), T( H ), T( I ), T( J ), T( K ) ) > {};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K >
-struct _EngineTypeTraits< R( A, B, C, D, E, F, G, H, I, J, K, ... ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), T( D ), T( E ), T( F ), T( G ), T( H ), T( I ), T( J ), T( K ), ... ) > {};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L >
-struct _EngineTypeTraits< R( A, B, C, D, E, F, G, H, I, J, K, L ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), T( D ), T( E ), T( F ), T( G ), T( H ), T( I ), T( J ), T( K ), T( L ) ) > {};
-template< typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K, typename L >
-struct _EngineTypeTraits< R( A, B, C, D, E, F, G, H, I, J, K, L, ... ) > : public _EngineFunctionTypeTraits< T( R )( T( A ), T( B ), T( C ), T( D ), T( E ), T( F ), T( G ), T( H ), T( I ), T( J ), T( K ), T( L ), ... ) > {};
+template<typename R, typename ...ArgTs>
+struct _EngineTypeTraits< R(ArgTs ...) > : public _EngineFunctionTypeTraits<T(R)(T(ArgTs)...)> {};
+template<typename R, typename ...ArgTs>
+struct _EngineTypeTraits< R(ArgTs ..., ...) > : public _EngineFunctionTypeTraits<T(R)(T(ArgTs)..., ...)> {};
 
 #undef T
 

Engine/source/gfx/gfxShader.cpp

@@ -178,7 +178,7 @@ void GFXShader::_unlinkBuffer( GFXShaderConstBuffer *buf )
 
 
 DefineEngineFunction( addGlobalShaderMacro, void, 
-   ( const char *name, const char *value ), ( NULL ),
+   ( const char *name, const char *value ), ( nullAsType<const char*>() ),
    "Adds a global shader macro which will be merged with the script defined "
    "macros on every shader.  The macro will replace the value of an existing "
    "macro of the same name.  For the new macro to take effect all the shaders "

Engine/source/gfx/video/videoCapture.cpp

@@ -340,7 +340,7 @@ DefineEngineFunction( stopVideoCapture, void, (),,
 
 DefineEngineFunction( playJournalToVideo, void, 
    ( const char *journalFile, const char *videoFile, const char *encoder, F32 framerate, Point2I resolution ),
-	( NULL, "THEORA", 30.0f, Point2I::Zero ),
+   ( nullAsType<const char*>(), "THEORA", 30.0f, Point2I::Zero ),
    "Load a journal file and capture it video.\n"
    "@ingroup Rendering\n" )
 {
@@ -357,4 +357,4 @@ DefineEngineFunction( playJournalToVideo, void,
    VIDCAP->waitForCanvas();
 
    Journal::Play( journalFile );
-}
+}

Engine/source/gui/core/guiCanvas.cpp

@@ -52,42 +52,42 @@
 IMPLEMENT_CONOBJECT(GuiCanvas);
 
 ConsoleDocClass( GuiCanvas,
-	"@brief A canvas on which rendering occurs.\n\n"
+   "@brief A canvas on which rendering occurs.\n\n"
 
-	"@section GuiCanvas_contents What a GUICanvas Can Contain...\n\n"
+   "@section GuiCanvas_contents What a GUICanvas Can Contain...\n\n"
 
-	"@subsection GuiCanvas_content_contentcontrol Content Control\n"
-	"A content control is the top level GuiControl for a screen. This GuiControl "
-	"will be the parent control for all other GuiControls on that particular "
-	"screen.\n\n"
+   "@subsection GuiCanvas_content_contentcontrol Content Control\n"
+   "A content control is the top level GuiControl for a screen. This GuiControl "
+   "will be the parent control for all other GuiControls on that particular "
+   "screen.\n\n"
 
-	"@subsection GuiCanvas_content_dialogs Dialogs\n\n"
+   "@subsection GuiCanvas_content_dialogs Dialogs\n\n"
 
-	"A dialog is essentially another screen, only it gets overlaid on top of the "
-	"current content control, and all input goes to the dialog. This is most akin "
-	"to the \"Open File\" dialog box found in most operating systems. When you "
-	"choose to open a file, and the \"Open File\" dialog pops up, you can no longer "
-	"send input to the application, and must complete or cancel the open file "
-	"request. Torque keeps track of layers of dialogs. The dialog with the highest "
-	"layer is on top and will get all the input, unless the dialog is "
-	"modeless, which is a profile option.\n\n"
+   "A dialog is essentially another screen, only it gets overlaid on top of the "
+   "current content control, and all input goes to the dialog. This is most akin "
+   "to the \"Open File\" dialog box found in most operating systems. When you "
+   "choose to open a file, and the \"Open File\" dialog pops up, you can no longer "
+   "send input to the application, and must complete or cancel the open file "
+   "request. Torque keeps track of layers of dialogs. The dialog with the highest "
+   "layer is on top and will get all the input, unless the dialog is "
+   "modeless, which is a profile option.\n\n"
 
-	"@see GuiControlProfile\n\n"
+   "@see GuiControlProfile\n\n"
 
-	"@section GuiCanvas_dirty Dirty Rectangles\n\n"
+   "@section GuiCanvas_dirty Dirty Rectangles\n\n"
 
-	"The GuiCanvas is based on dirty regions. "
-	"Every frame the canvas paints only the areas of the canvas that are 'dirty' "
-	"or need updating. In most cases, this only is the area under the mouse cursor. "
-	"This is why if you look in guiCanvas.cc the call to glClear is commented out. "
-	
-	"What you will see is a black screen, except in the dirty regions, where the "
-	"screen will be painted normally. If you are making an animated GuiControl "
-	"you need to add your control to the dirty areas of the canvas.\n\n"
+   "The GuiCanvas is based on dirty regions. "
+   "Every frame the canvas paints only the areas of the canvas that are 'dirty' "
+   "or need updating. In most cases, this only is the area under the mouse cursor. "
+   "This is why if you look in guiCanvas.cc the call to glClear is commented out. "
+   
+   "What you will see is a black screen, except in the dirty regions, where the "
+   "screen will be painted normally. If you are making an animated GuiControl "
+   "you need to add your control to the dirty areas of the canvas.\n\n"
 
-	"@see GuiControl\n\n"
+   "@see GuiControl\n\n"
 
-	"@ingroup GuiCore\n");
+   "@ingroup GuiCore\n");
 
 ColorI gCanvasClearColor( 255, 0, 255 ); ///< For GFX->clear
 
@@ -209,29 +209,29 @@ bool GuiCanvas::onAdd()
    //If we're recording, store the intial video resolution
    if (Journal::IsRecording())
    {
-	   Journal::Write(vm.resolution.x);
-	   Journal::Write(vm.resolution.y);
-	   Journal::Write(vm.fullScreen);
+      Journal::Write(vm.resolution.x);
+      Journal::Write(vm.resolution.y);
+      Journal::Write(vm.fullScreen);
    }
 
    //If we're playing, read the intial video resolution from the journal
    if (Journal::IsPlaying())
    {
-	   Journal::Read(&vm.resolution.x);
-	   Journal::Read(&vm.resolution.y);
-	   Journal::Read(&vm.fullScreen);
+      Journal::Read(&vm.resolution.x);
+      Journal::Read(&vm.resolution.y);
+      Journal::Read(&vm.fullScreen);
    }
 
    if (a && a->mType != NullDevice)
    {
       mPlatformWindow = WindowManager->createWindow(newDevice, vm);
 
-		//Disable window resizing if recording ir playing a journal
-		if (Journal::IsRecording() || Journal::IsPlaying())					
-			mPlatformWindow->lockSize(true);
-		
-		// Set a minimum on the window size so people can't break us by resizing tiny.
-		mPlatformWindow->setMinimumWindowSize(Point2I(640,480));
+      //Disable window resizing if recording ir playing a journal
+      if (Journal::IsRecording() || Journal::IsPlaying())               
+         mPlatformWindow->lockSize(true);
+      
+      // Set a minimum on the window size so people can't break us by resizing tiny.
+      mPlatformWindow->setMinimumWindowSize(Point2I(640,480));
 
       // Now, we have to hook in our event callbacks so we'll get
       // appropriate events from the window.
@@ -326,12 +326,12 @@ CanvasSizeChangeSignal GuiCanvas::smCanvasSizeChangeSignal;
 void GuiCanvas::handleResize( WindowId did, S32 width, S32 height )
 {
    getCanvasSizeChangeSignal().trigger(this);
-	if (Journal::IsPlaying() && mPlatformWindow)
-	{
-		mPlatformWindow->lockSize(false);
-		mPlatformWindow->setSize(Point2I(width, height));	
-		mPlatformWindow->lockSize(true);
-	}
+   if (Journal::IsPlaying() && mPlatformWindow)
+   {
+      mPlatformWindow->lockSize(false);
+      mPlatformWindow->setSize(Point2I(width, height));  
+      mPlatformWindow->lockSize(true);
+   }
 
    // Notify the scripts
    if ( isMethod( "onResize" ) )
@@ -342,9 +342,9 @@ void GuiCanvas::handlePaintEvent(WindowId did)
 {
    bool canRender = mPlatformWindow->isVisible() && GFX->allowRender() && !GFX->canCurrentlyRender();
    
-	// Do the screenshot first.
+   // Do the screenshot first.
    if ( gScreenShot != NULL && gScreenShot->isPending() && canRender )
-		gScreenShot->capture( this );
+      gScreenShot->capture( this );
 
    // If the video capture is waiting for a canvas, start the capture
    if ( VIDCAP->isWaitingForCanvas() && canRender )
@@ -560,19 +560,19 @@ bool GuiCanvas::tabNext(void)
       //save the old
       GuiControl *oldResponder = mFirstResponder;
 
-		GuiControl* newResponder = ctrl->findNextTabable(mFirstResponder);
+      GuiControl* newResponder = ctrl->findNextTabable(mFirstResponder);
       if ( !newResponder )
          newResponder = ctrl->findFirstTabable();
 
-		if ( newResponder && newResponder != oldResponder )
-		{
-			newResponder->setFirstResponder();
+      if ( newResponder && newResponder != oldResponder )
+      {
+         newResponder->setFirstResponder();
 
          // CodeReview Can this get killed? Note tabPrev code. BJG - 3/25/07
-//      	if ( oldResponder )
-//         	oldResponder->onLoseFirstResponder();
+//       if ( oldResponder )
+//          oldResponder->onLoseFirstResponder();
          return true;
-		}
+      }
    }
    return false;
 }
@@ -585,30 +585,30 @@ bool GuiCanvas::tabPrev(void)
       //save the old
       GuiControl *oldResponder = mFirstResponder;
 
-		GuiControl* newResponder = ctrl->findPrevTabable(mFirstResponder);
-		if ( !newResponder )
+      GuiControl* newResponder = ctrl->findPrevTabable(mFirstResponder);
+      if ( !newResponder )
          newResponder = ctrl->findLastTabable();
 
-		if ( newResponder && newResponder != oldResponder )
-		{
-			newResponder->setFirstResponder();
-	
+      if ( newResponder && newResponder != oldResponder )
+      {
+         newResponder->setFirstResponder();
+   
          // CodeReview As with tabNext() above, looks like this can now go. DAW - 7/05/09
-	      //if ( oldResponder )
-	      //   oldResponder->onLoseFirstResponder();
+         //if ( oldResponder )
+         //   oldResponder->onLoseFirstResponder();
 
          return true;
-		}
+      }
    }
    return false;
 }
 
 bool GuiCanvas::processInputEvent(InputEventInfo &inputEvent)
 {
-	// First call the general input handler (on the extremely off-chance that it will be handled):
-	if (mFirstResponder &&  mFirstResponder->onInputEvent(inputEvent))
+   // First call the general input handler (on the extremely off-chance that it will be handled):
+   if (mFirstResponder &&  mFirstResponder->onInputEvent(inputEvent))
    {
-		return(true);
+      return(true);
    }
 
    switch (inputEvent.deviceType)
@@ -1786,9 +1786,9 @@ void GuiCanvas::renderFrame(bool preRenderOnly, bool bufferSwap /* = true */)
       addUpdateRegion(pos - Point2I(2, 2), Point2I(cext.x + 4, cext.y + 4));
    }
 
-	mLastCursorEnabled = cursorVisible;
-	mLastCursor = mouseCursor;
-	mLastCursorPt = cursorPos;
+   mLastCursorEnabled = cursorVisible;
+   mLastCursor = mouseCursor;
+   mLastCursorPt = cursorPos;
 
    // Begin GFX
    PROFILE_START(GFXBeginScene);
@@ -1830,7 +1830,7 @@ void GuiCanvas::renderFrame(bool preRenderOnly, bool bufferSwap /* = true */)
 
    resetUpdateRegions();
 
-	// Make sure we have a clean matrix state 
+   // Make sure we have a clean matrix state 
    // before we start rendering anything!   
    GFX->setWorldMatrix( MatrixF::Identity );
    GFX->setViewMatrix( MatrixF::Identity );
@@ -2039,46 +2039,46 @@ void GuiCanvas::resetUpdateRegions()
 
 void GuiCanvas::setFirstResponder( GuiControl* newResponder )
 {
-	GuiControl* oldResponder = mFirstResponder;
-	Parent::setFirstResponder( newResponder );
+   GuiControl* oldResponder = mFirstResponder;
+   Parent::setFirstResponder( newResponder );
    
    if( oldResponder == mFirstResponder )
       return;
 
-	if( oldResponder && ( oldResponder != newResponder ) )
-		oldResponder->onLoseFirstResponder();
+   if( oldResponder && ( oldResponder != newResponder ) )
+      oldResponder->onLoseFirstResponder();
       
    if( newResponder && ( newResponder != oldResponder ) )
       newResponder->onGainFirstResponder();
 }
 
 DefineEngineMethod( GuiCanvas, getContent, S32, (),,
-				   "@brief Get the GuiControl which is being used as the content.\n\n"
+               "@brief Get the GuiControl which is being used as the content.\n\n"
 
-				   "@tsexample\n"
-				   "Canvas.getContent();\n"
-				   "@endtsexample\n\n"
+               "@tsexample\n"
+               "Canvas.getContent();\n"
+               "@endtsexample\n\n"
 
-				   "@return ID of current content control")
+               "@return ID of current content control")
 {
-	GuiControl *ctrl = object->getContentControl();
+   GuiControl *ctrl = object->getContentControl();
    if(ctrl)
       return ctrl->getId();
    return -1;
 }
 
 DefineEngineMethod( GuiCanvas, setContent, void, (GuiControl* ctrl),,
-				   "@brief Set the content of the canvas to a specified control.\n\n"
+               "@brief Set the content of the canvas to a specified control.\n\n"
 
-				   "@param ctrl ID or name of GuiControl to set content to\n\n"
+               "@param ctrl ID or name of GuiControl to set content to\n\n"
 
-				   "@tsexample\n"
-				   "Canvas.setContent(PlayGui);\n"
-				   "@endtsexample\n\n")
+               "@tsexample\n"
+               "Canvas.setContent(PlayGui);\n"
+               "@endtsexample\n\n")
 {
-	// Not using old error reporting until we modify the engineAPI - mperry
+   // Not using old error reporting until we modify the engineAPI - mperry
 
-	//GuiControl *gui = NULL;
+   //GuiControl *gui = NULL;
  //  if(argv[2][0])
  //  {
  //     if (!Sim::findObject(argv[2], gui))
@@ -2088,11 +2088,11 @@ DefineEngineMethod( GuiCanvas, setContent, void, (GuiControl* ctrl),,
  //     }
  //  }
 
-	if(!ctrl)
-	{
-		Con::errorf("GuiCanvas::setContent - Invalid control specified')");
-		return;
-	}
+   if(!ctrl)
+   {
+      Con::errorf("GuiCanvas::setContent - Invalid control specified')");
+      return;
+   }
 
    //set the new content control
    object->setContentControl(ctrl);
@@ -2111,11 +2111,11 @@ ConsoleDocFragment _pushDialog(
 );
 
 DefineConsoleMethod( GuiCanvas, pushDialog, void, (const char * ctrlName, S32 layer, bool center), ( 0, false), "(GuiControl ctrl, int layer=0, bool center=false)"
-			  "@hide")
+           "@hide")
 {
    GuiControl *gui;
 
-   if (!	Sim::findObject(ctrlName, gui))
+   if (! Sim::findObject(ctrlName, gui))
    {
       Con::printf("pushDialog(): Invalid control: %s", ctrlName);
       return;
@@ -2147,8 +2147,8 @@ ConsoleDocFragment _popDialog2(
    "void popDialog();"
 );
 
-DefineConsoleMethod( GuiCanvas, popDialog, void, (GuiControl * gui), (NULL), "(GuiControl ctrl=NULL)"
-			  "@hide")
+DefineConsoleMethod( GuiCanvas, popDialog, void, (GuiControl * gui), (nullAsType<GuiControl*>()), "(GuiControl ctrl=NULL)"
+           "@hide")
 {
    if (gui)
       object->popDialogControl(gui);
@@ -2157,160 +2157,160 @@ DefineConsoleMethod( GuiCanvas, popDialog, void, (GuiControl * gui), (NULL), "(G
 }
 
 ConsoleDocFragment _popLayer1(
-	"@brief Removes the top most layer of dialogs\n\n"
-	"@tsexample\n"
-	"Canvas.popLayer();\n"
-	"@endtsexample\n\n",
-	"GuiCanvas",
-	"void popLayer();"
+   "@brief Removes the top most layer of dialogs\n\n"
+   "@tsexample\n"
+   "Canvas.popLayer();\n"
+   "@endtsexample\n\n",
+   "GuiCanvas",
+   "void popLayer();"
 );
 
 ConsoleDocFragment _popLayer2(
-	"@brief Removes a specified layer of dialogs\n\n"
-	"@param layer Number of the layer to pop\n\n"
-	"@tsexample\n"
-	"Canvas.popLayer(1);\n"
-	"@endtsexample\n\n",
-	"GuiCanvas",
-	"void popLayer(S32 layer);"
+   "@brief Removes a specified layer of dialogs\n\n"
+   "@param layer Number of the layer to pop\n\n"
+   "@tsexample\n"
+   "Canvas.popLayer(1);\n"
+   "@endtsexample\n\n",
+   "GuiCanvas",
+   "void popLayer(S32 layer);"
 );
 
 DefineConsoleMethod( GuiCanvas, popLayer, void, (S32 layer), (0), "(int layer)" 
-			  "@hide")
+           "@hide")
 {
 
    object->popDialogControl(layer);
 }
 
 DefineEngineMethod( GuiCanvas, cursorOn, void, (),,
-				   "@brief Turns on the mouse cursor.\n\n"
-				   "@tsexample\n"
-				   "Canvas.cursorOn();\n"
-				   "@endtsexample\n\n")
+               "@brief Turns on the mouse cursor.\n\n"
+               "@tsexample\n"
+               "Canvas.cursorOn();\n"
+               "@endtsexample\n\n")
 {
-	object->setCursorON(true);
+   object->setCursorON(true);
 }
 
 DefineEngineMethod( GuiCanvas, cursorOff, void, (),,
-				    "@brief Turns on the mouse off.\n\n"
-				   "@tsexample\n"
-				   "Canvas.cursorOff();\n"
-				   "@endtsexample\n\n")
+                "@brief Turns on the mouse off.\n\n"
+               "@tsexample\n"
+               "Canvas.cursorOff();\n"
+               "@endtsexample\n\n")
 {
-	object->setCursorON(false);
+   object->setCursorON(false);
 }
 
 
 DefineEngineMethod( GuiCanvas, setCursor, void, (GuiCursor* cursor),,
-				   "@brief Sets the cursor for the canvas.\n\n"
+               "@brief Sets the cursor for the canvas.\n\n"
 
-				   "@param cursor Name of the GuiCursor to use\n\n"
+               "@param cursor Name of the GuiCursor to use\n\n"
 
-				   "@tsexample\n"
-				   "Canvas.setCursor(\"DefaultCursor\");\n"
-				   "@endtsexample\n\n")
+               "@tsexample\n"
+               "Canvas.setCursor(\"DefaultCursor\");\n"
+               "@endtsexample\n\n")
 {
-	if(!cursor)
-	{
-		Con::errorf("GuiCanvas::setCursor - Invalid GuiCursor name or ID");
-		return;
-	}
-	object->setCursor(cursor);
+   if(!cursor)
+   {
+      Con::errorf("GuiCanvas::setCursor - Invalid GuiCursor name or ID");
+      return;
+   }
+   object->setCursor(cursor);
 }
 
 DefineEngineMethod( GuiCanvas, renderFront, void, ( bool enable ),,
-				   "@brief This turns on/off front-buffer rendering.\n\n"
+               "@brief This turns on/off front-buffer rendering.\n\n"
 
-				   "@param enable True if all rendering should be done to the front buffer\n\n"
+               "@param enable True if all rendering should be done to the front buffer\n\n"
 
-				   "@tsexample\n"
-				   "Canvas.renderFront(false);\n"
-				   "@endtsexample\n\n")
+               "@tsexample\n"
+               "Canvas.renderFront(false);\n"
+               "@endtsexample\n\n")
 {
-	object->setRenderFront(enable);
+   object->setRenderFront(enable);
 }
 
 DefineEngineMethod( GuiCanvas, showCursor, void, (),,
-				   "@brief Enable rendering of the cursor.\n\n"
+               "@brief Enable rendering of the cursor.\n\n"
 
-				   "@tsexample\n"
-				   "Canvas.showCursor();\n"
-				   "@endtsexample\n\n")
+               "@tsexample\n"
+               "Canvas.showCursor();\n"
+               "@endtsexample\n\n")
 {
-	object->showCursor(true);
+   object->showCursor(true);
 }
 
 DefineEngineMethod( GuiCanvas, hideCursor, void, (),,
-				   "@brief Disable rendering of the cursor.\n\n"
+               "@brief Disable rendering of the cursor.\n\n"
 
-				   "@tsexample\n"
-				   "Canvas.hideCursor();\n"
-				   "@endtsexample\n\n")
+               "@tsexample\n"
+               "Canvas.hideCursor();\n"
+               "@endtsexample\n\n")
 {
-	object->showCursor(false);
+   object->showCursor(false);
 }
 
 DefineEngineMethod( GuiCanvas, isCursorOn, bool, (),,
-				   "@brief Determines if mouse cursor is enabled.\n\n"
+               "@brief Determines if mouse cursor is enabled.\n\n"
 
-				   "@tsexample\n"
-				   "// Is cursor on?\n"
-				   "if(Canvas.isCursorOn())\n"
-				   "	echo(\"Canvas cursor is on\");\n"
-				   "@endtsexample\n\n"
-				   "@return Returns true if the cursor is on.\n\n")
+               "@tsexample\n"
+               "// Is cursor on?\n"
+               "if(Canvas.isCursorOn())\n"
+               "  echo(\"Canvas cursor is on\");\n"
+               "@endtsexample\n\n"
+               "@return Returns true if the cursor is on.\n\n")
 {
-	return object->isCursorON();
+   return object->isCursorON();
 }
 
 DefineEngineMethod( GuiCanvas, isCursorShown, bool, (),,
-				   "@brief Determines if mouse cursor is rendering.\n\n"
+               "@brief Determines if mouse cursor is rendering.\n\n"
 
-				   "@tsexample\n"
-				   "// Is cursor rendering?\n"
-				   "if(Canvas.isCursorShown())\n"
-				   "	echo(\"Canvas cursor is rendering\");\n"
-				   "@endtsexample\n\n"
-				   "@return Returns true if the cursor is rendering.\n\n")
+               "@tsexample\n"
+               "// Is cursor rendering?\n"
+               "if(Canvas.isCursorShown())\n"
+               "  echo(\"Canvas cursor is rendering\");\n"
+               "@endtsexample\n\n"
+               "@return Returns true if the cursor is rendering.\n\n")
 {
-	return object->isCursorShown();
+   return object->isCursorShown();
 }
 
 DefineEngineMethod( GuiCanvas, repaint, void, ( S32 elapsedMS ), (0),
-				   "@brief Force canvas to redraw.\n"
+               "@brief Force canvas to redraw.\n"
                "If the elapsed time is greater than the time since the last paint "
                "then the repaint will be skipped.\n"
                "@param elapsedMS The optional elapsed time in milliseconds.\n\n"
 
-				   "@tsexample\n"
-				   "Canvas.repaint();\n"
-				   "@endtsexample\n\n")
+               "@tsexample\n"
+               "Canvas.repaint();\n"
+               "@endtsexample\n\n")
 {
-	object->repaint(elapsedMS < 0 ? 0 : elapsedMS);
+   object->repaint(elapsedMS < 0 ? 0 : elapsedMS);
 }
 
 DefineEngineMethod( GuiCanvas, reset, void, (),,
-				   "@brief Reset the update regions for the canvas.\n\n"
+               "@brief Reset the update regions for the canvas.\n\n"
 
-				   "@tsexample\n"
-				   "Canvas.reset();\n"
-				   "@endtsexample\n\n")
+               "@tsexample\n"
+               "Canvas.reset();\n"
+               "@endtsexample\n\n")
 {
-	object->resetUpdateRegions();
+   object->resetUpdateRegions();
 }
 
 DefineEngineMethod( GuiCanvas, getCursorPos, Point2I, (),,
-				   "@brief Get the current position of the cursor in screen-space. Note that this position"
+               "@brief Get the current position of the cursor in screen-space. Note that this position"
                " might be outside the Torque window. If you want to get the position within the Canvas,"
                " call screenToClient on the result.\n\n"
                "@see Canvas::screenToClient()\n\n"
-				   "@param param Description\n\n"
-				   "@tsexample\n"
-				   "%cursorPos = Canvas.getCursorPos();\n"
-				   "@endtsexample\n\n"
-				   "@return Screen coordinates of mouse cursor, in format \"X Y\"")
+               "@param param Description\n\n"
+               "@tsexample\n"
+               "%cursorPos = Canvas.getCursorPos();\n"
+               "@endtsexample\n\n"
+               "@return Screen coordinates of mouse cursor, in format \"X Y\"")
 {
-	return object->getCursorPos();
+   return object->getCursorPos();
 }
 
 ConsoleDocFragment _setCursorPos1(
@@ -2334,21 +2334,21 @@ ConsoleDocFragment _setCursorPos2(
 );
 
 DefineConsoleMethod( GuiCanvas, setCursorPos, void, (Point2I pos), , "(Point2I pos)"
-			  "@hide")
+           "@hide")
 {
 
    object->setCursorPos(pos);
 }
 
 DefineEngineMethod( GuiCanvas, getMouseControl, S32, (),,
-				   "@brief Gets the gui control under the mouse.\n\n"
-				   "@tsexample\n"
-				   "%underMouse = Canvas.getMouseControl();\n"
-				   "@endtsexample\n\n"
+               "@brief Gets the gui control under the mouse.\n\n"
+               "@tsexample\n"
+               "%underMouse = Canvas.getMouseControl();\n"
+               "@endtsexample\n\n"
 
-				   "@return ID of the gui control, if one was found. NULL otherwise")
+               "@return ID of the gui control, if one was found. NULL otherwise")
 {
-	GuiControl* control = object->getMouseControl();
+   GuiControl* control = object->getMouseControl();
    if (control)
       return control->getId();
    
@@ -2356,18 +2356,18 @@ DefineEngineMethod( GuiCanvas, getMouseControl, S32, (),,
 }
 
 DefineEngineFunction(excludeOtherInstance, bool, (const char* appIdentifer),,
-					 "@brief Used to exclude/prevent all other instances using the same identifier specified\n\n"
+                "@brief Used to exclude/prevent all other instances using the same identifier specified\n\n"
 
-					 "@note Not used on OSX, Xbox, or in Win debug builds\n\n"
+                "@note Not used on OSX, Xbox, or in Win debug builds\n\n"
 
-					 "@param appIdentifier Name of the app set up for exclusive use.\n"
+                "@param appIdentifier Name of the app set up for exclusive use.\n"
 
-					 "@return False if another app is running that specified the same appIdentifier\n\n"
+                "@return False if another app is running that specified the same appIdentifier\n\n"
 
-					 "@ingroup Platform\n"
-					 "@ingroup GuiCore")
+                "@ingroup Platform\n"
+                "@ingroup GuiCore")
 {
-	   // mac/360 can only run one instance in general.
+      // mac/360 can only run one instance in general.
 #if !defined(TORQUE_OS_MAC) && !defined(TORQUE_OS_XENON) && !defined(TORQUE_DEBUG) && !defined(TORQUE_OS_LINUX)
    return Platform::excludeOtherInstances(appIdentifer);
 #else
@@ -2377,82 +2377,82 @@ DefineEngineFunction(excludeOtherInstance, bool, (const char* appIdentifer),,
 }
 
 DefineEngineMethod( GuiCanvas, getExtent, Point2I, (),,
-				   "@brief Returns the dimensions of the canvas\n\n"
+               "@brief Returns the dimensions of the canvas\n\n"
 
-				   "@tsexample\n"
-				   "%extent = Canvas.getExtent();\n"
-				   "@endtsexample\n\n"
+               "@tsexample\n"
+               "%extent = Canvas.getExtent();\n"
+               "@endtsexample\n\n"
 
-				   "@return Width and height of canvas. Formatted as numerical values in a single string \"# #\"")
+               "@return Width and height of canvas. Formatted as numerical values in a single string \"# #\"")
 {
-	return object->getExtent();
+   return object->getExtent();
 }
 
 
 DefineEngineMethod( GuiCanvas, setWindowTitle, void, ( const char* newTitle),,
-				   "@brief Change the title of the OS window.\n\n"
+               "@brief Change the title of the OS window.\n\n"
 
-				   "@param newTitle String containing the new name\n\n"
+               "@param newTitle String containing the new name\n\n"
 
-				   "@tsexample\n"
-				   "Canvas.setWindowTitle(\"Documentation Rocks!\");\n"
-				   "@endtsexample\n\n")
+               "@tsexample\n"
+               "Canvas.setWindowTitle(\"Documentation Rocks!\");\n"
+               "@endtsexample\n\n")
 {
-	object->setWindowTitle(newTitle);
+   object->setWindowTitle(newTitle);
 }
 
 
 DefineEngineMethod( GuiCanvas, findFirstMatchingMonitor, S32, (const char* name),,
-				   "@brief Find the first monitor index that matches the given name.\n\n"
+               "@brief Find the first monitor index that matches the given name.\n\n"
                "The actual match algorithm depends on the implementation.\n"
                "@param name The name to search for.\n\n"
-				   "@return The number of monitors attached to the system, including the default monoitor.")
+               "@return The number of monitors attached to the system, including the default monoitor.")
 {
    return PlatformWindowManager::get()->findFirstMatchingMonitor(name);
 }
 
 DefineEngineMethod( GuiCanvas, getMonitorCount, S32, (),,
-				   "@brief Gets the number of monitors attached to the system.\n\n"
+               "@brief Gets the number of monitors attached to the system.\n\n"
 
-				   "@return The number of monitors attached to the system, including the default monoitor.")
+               "@return The number of monitors attached to the system, including the default monoitor.")
 {
    return PlatformWindowManager::get()->getMonitorCount();
 }
 
 DefineEngineMethod( GuiCanvas, getMonitorName, const char*, (S32 index),,
-				   "@brief Gets the name of the requested monitor.\n\n"
+               "@brief Gets the name of the requested monitor.\n\n"
                "@param index The monitor index.\n\n"
-				   "@return The name of the requested monitor.")
+               "@return The name of the requested monitor.")
 {
    return PlatformWindowManager::get()->getMonitorName(index);
 }
 
 DefineEngineMethod( GuiCanvas, getMonitorRect, RectI, (S32 index),,
-				   "@brief Gets the region of the requested monitor.\n\n"
+               "@brief Gets the region of the requested monitor.\n\n"
                "@param index The monitor index.\n\n"
-				   "@return The rectangular region of the requested monitor.")
+               "@return The rectangular region of the requested monitor.")
 {
    return PlatformWindowManager::get()->getMonitorRect(index);
 }
 
 
 DefineEngineMethod( GuiCanvas, getVideoMode, const char*, (),,
-				   "@brief Gets the current screen mode as a string.\n\n"
+               "@brief Gets the current screen mode as a string.\n\n"
 
-				   "The return string will contain 5 values (width, height, fullscreen, bitdepth, refreshRate). "
-				   "You will need to parse out each one for individual use.\n\n"
+               "The return string will contain 5 values (width, height, fullscreen, bitdepth, refreshRate). "
+               "You will need to parse out each one for individual use.\n\n"
 
-				   "@tsexample\n"
-				   "%screenWidth = getWord(Canvas.getVideoMode(), 0);\n"
-				   "%screenHeight = getWord(Canvas.getVideoMode(), 1);\n"
-				   "%isFullscreen = getWord(Canvas.getVideoMode(), 2);\n"
-				   "%bitdepth = getWord(Canvas.getVideoMode(), 3);\n"
-				   "%refreshRate = getWord(Canvas.getVideoMode(), 4);\n"
-				   "@endtsexample\n\n"
+               "@tsexample\n"
+               "%screenWidth = getWord(Canvas.getVideoMode(), 0);\n"
+               "%screenHeight = getWord(Canvas.getVideoMode(), 1);\n"
+               "%isFullscreen = getWord(Canvas.getVideoMode(), 2);\n"
+               "%bitdepth = getWord(Canvas.getVideoMode(), 3);\n"
+               "%refreshRate = getWord(Canvas.getVideoMode(), 4);\n"
+               "@endtsexample\n\n"
 
-				   "@return String formatted with screen width, screen height, screen mode, bit depth, and refresh rate.")
+               "@return String formatted with screen width, screen height, screen mode, bit depth, and refresh rate.")
 {
-	// Grab the video mode.
+   // Grab the video mode.
    if (!object->getPlatformWindow())
       return "";
 
@@ -2463,17 +2463,17 @@ DefineEngineMethod( GuiCanvas, getVideoMode, const char*, (),,
 
 
 DefineEngineMethod( GuiCanvas, getModeCount, S32, (),,
-				   "@brief Gets the number of modes available on this device.\n\n"
+               "@brief Gets the number of modes available on this device.\n\n"
 
-				   "@param param Description\n\n"
+               "@param param Description\n\n"
 
-				   "@tsexample\n"
-				   "%modeCount = Canvas.getModeCount()\n"
-				   "@endtsexample\n\n"
+               "@tsexample\n"
+               "%modeCount = Canvas.getModeCount()\n"
+               "@endtsexample\n\n"
 
-				   "@return The number of video modes supported by the device")
+               "@return The number of video modes supported by the device")
 {
-	if (!object->getPlatformWindow())
+   if (!object->getPlatformWindow())
       return 0;
 
    // Grab the available mode list from the device.
@@ -2485,12 +2485,12 @@ DefineEngineMethod( GuiCanvas, getModeCount, S32, (),,
 }
 
 DefineEngineMethod( GuiCanvas, getMode, const char*, (S32 modeId),,
-				   "@brief Gets information on the specified mode of this device.\n\n"
-				   "@param modeId Index of the mode to get data from.\n"
-				   "@return A video mode string given an adapter and mode index.\n\n"
-				   "@see GuiCanvas::getVideoMode()")
+               "@brief Gets information on the specified mode of this device.\n\n"
+               "@param modeId Index of the mode to get data from.\n"
+               "@return A video mode string given an adapter and mode index.\n\n"
+               "@see GuiCanvas::getVideoMode()")
 {
-	if (!object->getPlatformWindow())
+   if (!object->getPlatformWindow())
       return 0;
 
    // Grab the available mode list from the device.
@@ -2515,14 +2515,14 @@ DefineEngineMethod( GuiCanvas, getMode, const char*, (S32 modeId),,
 
 
 DefineEngineMethod( GuiCanvas, toggleFullscreen, void, (),,
-				   "@brief toggle canvas from fullscreen to windowed mode or back.\n\n"
+               "@brief toggle canvas from fullscreen to windowed mode or back.\n\n"
 
-				   "@tsexample\n"
-				   "// If we are in windowed mode, the following will put is in fullscreen\n"
-				   "Canvas.toggleFullscreen();"
-				   "@endtsexample\n\n")
+               "@tsexample\n"
+               "// If we are in windowed mode, the following will put is in fullscreen\n"
+               "Canvas.toggleFullscreen();"
+               "@endtsexample\n\n")
 {
-	if (Platform::getWebDeployment())
+   if (Platform::getWebDeployment())
       return;
 
    if (!object->getPlatformWindow())
@@ -2693,7 +2693,7 @@ DefineConsoleMethod( GuiCanvas, setVideoMode, void,
                "\\param fullscreen Specify true to run fullscreen or false to run in a window\n"
                "\\param bitDepth [optional] The desired bit-depth. Defaults to the current setting. This parameter is ignored if you are running in a window.\n"
                "\\param refreshRate [optional] The desired refresh rate. Defaults to the current setting. This parameter is ignored if you are running in a window"
-					"\\param antialiasLevel [optional] The level of anti-aliasing to apply 0 = none" )
+               "\\param antialiasLevel [optional] The level of anti-aliasing to apply 0 = none" )
 {
    if (!object->getPlatformWindow())
       return;

Engine/source/gui/editor/guiEditCtrl.cpp

@@ -716,16 +716,16 @@ void GuiEditCtrl::onRender(Point2I offset, const RectI &updateRect)
          ctOffset = getCurrentAddSet()->localToGlobalCoord(Point2I(0,0));
          RectI box(ctOffset.x, ctOffset.y, cext.x, cext.y);
 
-			box.inset( -5, -5 );
+         box.inset( -5, -5 );
          drawer->drawRect( box, ColorI( 50, 101, 152, 128 ) );
-			box.inset( 1, 1 );
+         box.inset( 1, 1 );
          drawer->drawRect( box, ColorI( 50, 101, 152, 128 ) );
-			box.inset( 1, 1 );
+         box.inset( 1, 1 );
          drawer->drawRect( box, ColorI( 50, 101, 152, 128 ) );
-			box.inset( 1, 1 );
+         box.inset( 1, 1 );
+         drawer->drawRect( box, ColorI( 50, 101, 152, 128 ) );
+         box.inset( 1, 1 );
          drawer->drawRect( box, ColorI( 50, 101, 152, 128 ) );
-			box.inset( 1, 1 );
-			drawer->drawRect( box, ColorI( 50, 101, 152, 128 ) );
       }
       Vector<GuiControl *>::iterator i;
       bool multisel = mSelectedControls.size() > 1;
@@ -2481,16 +2481,16 @@ DefineConsoleMethod( GuiEditCtrl, getContentControl, S32, (), , "() - Return the
 
 DefineConsoleMethod( GuiEditCtrl, setContentControl, void, (GuiControl *ctrl ), , "( GuiControl ctrl ) - Set the toplevel control to edit in the GUI editor." )
 {
-	if (ctrl)
-		object->setContentControl(ctrl);
+   if (ctrl)
+      object->setContentControl(ctrl);
 }
 
 //-----------------------------------------------------------------------------
 
 DefineConsoleMethod( GuiEditCtrl, addNewCtrl, void, (GuiControl *ctrl), , "(GuiControl ctrl)")
 {
-	if (ctrl)
-		object->addNewControl(ctrl);
+   if (ctrl)
+      object->addNewControl(ctrl);
 }
 
 //-----------------------------------------------------------------------------
@@ -2518,7 +2518,7 @@ DefineConsoleMethod( GuiEditCtrl, clearSelection, void, (), , "Clear selected co
 
 DefineConsoleMethod( GuiEditCtrl, select, void, (GuiControl *ctrl), , "(GuiControl ctrl)")
 {
-	if (ctrl)
+   if (ctrl)
    object->setSelection(ctrl, false);
 }
 
@@ -2526,7 +2526,7 @@ DefineConsoleMethod( GuiEditCtrl, select, void, (GuiControl *ctrl), , "(GuiContr
 
 DefineConsoleMethod( GuiEditCtrl, setCurrentAddSet, void, (GuiControl *addSet), , "(GuiControl ctrl)")
 {
-	if (addSet)
+   if (addSet)
    object->setCurrentAddSet(addSet);
 }
 
@@ -2582,7 +2582,7 @@ DefineConsoleMethod( GuiEditCtrl, moveSelection, void, (S32 dx, S32 dy), , "Move
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleMethod( GuiEditCtrl, saveSelection, void, (const char * filename), (NULL), "( string fileName=null ) - Save selection to file or clipboard.")
+DefineConsoleMethod( GuiEditCtrl, saveSelection, void, (const char * filename), (nullAsType<const char*>()), "( string fileName=null ) - Save selection to file or clipboard.")
 {
       
    object->saveSelection( filename );
@@ -2590,7 +2590,7 @@ DefineConsoleMethod( GuiEditCtrl, saveSelection, void, (const char * filename),
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleMethod( GuiEditCtrl, loadSelection, void, (const char * filename), (NULL), "( string fileName=null ) - Load selection from file or clipboard.")
+DefineConsoleMethod( GuiEditCtrl, loadSelection, void, (const char * filename), (nullAsType<const char*>()), "( string fileName=null ) - Load selection from file or clipboard.")
 {
 
    object->loadSelection( filename );

Engine/source/gui/editor/guiMenuBar.cpp

@@ -81,8 +81,8 @@ ConsoleDocClass( GuiMenuBar,
    "@tsexample\n"
    "new GuiMenuBar(newMenuBar)\n"
    "{\n"
-   "	Padding = \"0\";\n"
-   "	//Properties not specific to this control have been omitted from this example.\n"
+   "  Padding = \"0\";\n"
+   "  //Properties not specific to this control have been omitted from this example.\n"
    "};\n\n"
    "// Add a menu to the menu bar\n"
    "newMenuBar.addMenu(0,\"New Menu\");\n\n"
@@ -105,7 +105,7 @@ IMPLEMENT_CALLBACK( GuiMenuBar, onMouseInMenu, void, (bool isInMenu),( isInMenu
    "// Mouse enters or persists within the menu, causing the callback to occur.\n"
    "GuiMenuBar::onMouseInMenu(%this,%hasLeftMenu)\n"
    "{\n"
-   "	// Code to run when the callback occurs\n"
+   "  // Code to run when the callback occurs\n"
    "}\n"
    "@endtsexample\n\n"
    "@see GuiTickCtrl\n\n"
@@ -119,14 +119,14 @@ IMPLEMENT_CALLBACK( GuiMenuBar, onMenuSelect, void, ( S32 menuId, const char* me
    "// A menu has been selected, causing the callback to occur.\n"
    "GuiMenuBar::onMenuSelect(%this,%menuId,%menuText)\n"
    "{\n"
-   "	// Code to run when the callback occurs\n"
+   "  // Code to run when the callback occurs\n"
    "}\n"
    "@endtsexample\n\n"
    "@see GuiTickCtrl\n\n"
 );
 
 IMPLEMENT_CALLBACK( GuiMenuBar, onMenuItemSelect, void, ( S32 menuId, const char* menuText, S32 menuItemId, const char* menuItemText ),
-												   ( menuId, menuText, menuItemId, menuItemText ),
+                                       ( menuId, menuText, menuItemId, menuItemText ),
    "@brief Called whenever an item in a menu is selected.\n\n"
    "@param menuId Index id of the menu which contains the selected menu item\n"
    "@param menuText Text of the menu which contains the selected menu item\n\n"
@@ -136,7 +136,7 @@ IMPLEMENT_CALLBACK( GuiMenuBar, onMenuItemSelect, void, ( S32 menuId, const char
    "// A menu item has been selected, causing the callback to occur.\n"
    "GuiMenuBar::onMenuItemSelect(%this,%menuId,%menuText,%menuItemId,%menuItemText)\n"
    "{\n"
-   "	// Code to run when the callback occurs\n"
+   "  // Code to run when the callback occurs\n"
    "}\n"
    "@endtsexample\n\n"
    "@see GuiTickCtrl\n\n"
@@ -149,7 +149,7 @@ IMPLEMENT_CALLBACK( GuiMenuBar, onSubmenuSelect, void, ( S32 submenuId, const ch
    "@tsexample\n"
    "GuiMenuBar::onSubmenuSelect(%this,%submenuId,%submenuText)\n"
    "{\n"
-   "	// Code to run when the callback occurs\n"
+   "  // Code to run when the callback occurs\n"
    "}\n"
    "@endtsexample\n\n"
    "@see GuiTickCtrl\n\n"
@@ -216,7 +216,7 @@ DefineEngineMethod(GuiMenuBar, addMenu, void, (const char* menuText, S32 menuId)
 }
 
 DefineEngineMethod(GuiMenuBar, addMenuItem, void, (const char* targetMenu, const char* menuItemText, S32 menuItemId, const char* accelerator, int checkGroup, const char *cmd),
-												 ("","",0,NULL,-1,""),
+                                     ("","",0,nullAsType<const char*>(),-1,""),
    "@brief Adds a menu item to the specified menu.  The menu argument can be either the text of a menu or its id.\n\n"
    "@param menu Menu name or menu Id to add the new item to.\n"
    "@param menuItemText Text for the new menu item.\n"
@@ -637,7 +637,7 @@ DefineEngineMethod(GuiMenuBar, setMenuItemSubmenuState, void, (const char* menuT
 }
 
 DefineEngineMethod(GuiMenuBar, addSubmenuItem, void, (const char* menuTarget, const char* menuItem, const char* submenuItemText, 
-													  int submenuItemId, const char* accelerator, int checkGroup),,
+                                         int submenuItemId, const char* accelerator, int checkGroup),,
    "@brief Adds a menu item to the specified menu.  The menu argument can be either the text of a menu or its id.\n\n"
    "@param menuTarget Menu to affect a submenu in\n"
    "@param menuItem Menu item to affect\n"
@@ -814,21 +814,21 @@ void GuiMenuBar::addMenu(const char *menuText, U32 menuId)
 
 GuiMenuBar::Menu *GuiMenuBar::findMenu(const char *menu)
 {
-	if(dIsdigit(menu[0]))
-	{
-		U32 id = dAtoi(menu);
+   if(dIsdigit(menu[0]))
+   {
+      U32 id = dAtoi(menu);
       for (U32 i = 0; i < mMenuList.size(); ++i)
          if (id == mMenuList[i]->id)
             return mMenuList[i];
-		return NULL;
-	}
-	else
-	{
+      return NULL;
+   }
+   else
+   {
       for (U32 i = 0; i < mMenuList.size(); ++i)
          if (!dStricmp(menu, mMenuList[i]->text))
             return mMenuList[i];
-		return NULL;
-	}
+      return NULL;
+   }
 }
 
 GuiMenuBar::MenuItem *GuiMenuBar::findMenuItem(Menu *menu, const char *menuItem)
@@ -981,13 +981,13 @@ GuiMenuBar::MenuItem *GuiMenuBar::findSubmenuItem(Menu *menu, const char *menuIt
       U32 id = dAtoi(menuItem);
       for(MenuItem *walk = menu->firstMenuItem; walk; walk = walk->nextMenuItem)
          if(id == walk->id)
-		 {
-		    if(walk->isSubmenu && walk->submenu)
-			{
+       {
+          if(walk->isSubmenu && walk->submenu)
+         {
             return GuiMenuBar::findMenuItem(walk->submenu, submenuItem);
-			}
-			return NULL;
-		 }
+         }
+         return NULL;
+       }
       return NULL;
    }
    else
@@ -995,13 +995,13 @@ GuiMenuBar::MenuItem *GuiMenuBar::findSubmenuItem(Menu *menu, const char *menuIt
       //  Search by name
       for(MenuItem *walk = menu->firstMenuItem; walk; walk = walk->nextMenuItem)
          if(!dStricmp(menuItem, walk->text))
-		 {
-		    if(walk->isSubmenu && walk->submenu)
-			{
+       {
+          if(walk->isSubmenu && walk->submenu)
+         {
             return GuiMenuBar::findMenuItem(walk->submenu, submenuItem);
-			}
-			return NULL;
-		 }
+         }
+         return NULL;
+       }
       return NULL;
    }
 }
@@ -1021,7 +1021,7 @@ void GuiMenuBar::addSubmenuItem(Menu *menu, MenuItem *submenu, const char *text,
    if(submenu && !submenu->isSubmenu)
    {
       Con::errorf("GuiMenuBar::addSubmenuItem: Attempting to add menuitem '%s' to an invalid submenu",text);
-	  return;
+     return;
    }
 
    // allocate the new menu item
@@ -1074,7 +1074,7 @@ void GuiMenuBar::removeSubmenuItem(MenuItem *menuItem, MenuItem *submenuItem)
    if(menuItem && !menuItem->isSubmenu)
    {
       Con::errorf("GuiMenuBar::removeSubmenuItem: Attempting to remove submenuitem '%s' from an invalid submenu",submenuItem->text);
-	  return;
+     return;
    }
 
    GuiMenuBar::removeMenuItem(menuItem->submenu, submenuItem);
@@ -1087,7 +1087,7 @@ void GuiMenuBar::clearSubmenuItems(MenuItem *menuitem)
    if(menuitem && !menuitem->isSubmenu)
    {
       Con::errorf("GuiMenuBar::clearSubmenuItems: Attempting to clear an invalid submenu");
-	  return;
+     return;
    }
 
    while(menuitem->submenu->firstMenuItem)
@@ -1175,33 +1175,33 @@ void GuiMenuBar::onPreRender()
          if (!mMenuList[i]->visible)
             continue;
 
-		 // Bounds depends on if there is a bitmap to be drawn or not
+       // Bounds depends on if there is a bitmap to be drawn or not
          if (mMenuList[i]->bitmapIndex == -1)
-		 {
+       {
             // Text only
             mMenuList[i]->bounds.set(curX, 0, mProfile->mFont->getStrWidth(mMenuList[i]->text) + (mHorizontalMargin * 2), getHeight() - (mVerticalMargin * 2));
 
          } else
-		 {
+       {
             // Will the bitmap and text be draw?
           if (!mMenuList[i]->drawBitmapOnly)
-			{
+         {
                // Draw the bitmap and the text
                RectI *bitmapBounds = mProfile->mBitmapArrayRects.address();
                mMenuList[i]->bounds.set(curX, 0, bitmapBounds[mMenuList[i]->bitmapIndex].extent.x + mProfile->mFont->getStrWidth(mMenuList[i]->text) + (mHorizontalMargin * 2), getHeight() + (mVerticalMargin * 2));
 
-			} else
-			{
+         } else
+         {
                // Only the bitmap will be drawn
                RectI *bitmapBounds = mProfile->mBitmapArrayRects.address();
                mMenuList[i]->bounds.set(curX, 0, bitmapBounds[mMenuList[i]->bitmapIndex].extent.x + mBitmapMargin + (mHorizontalMargin * 2), getHeight() + (mVerticalMargin * 2));
-			}
-		 }
+         }
+       }
 
          curX += mMenuList[i]->bounds.extent.x;
       }
-		mouseOverMenu = NULL;
-		mouseDownMenu = NULL;
+      mouseOverMenu = NULL;
+      mouseDownMenu = NULL;
    }
 }
 
@@ -1222,35 +1222,35 @@ void GuiMenuBar::checkMenuMouseMove(const GuiEvent &event)
 void GuiMenuBar::onMouseMove(const GuiEvent &event)
 {
    Menu *hit = findHitMenu(event.mousePoint);
-	if(hit != mouseOverMenu)
-	{
-		//  If we need to, reset the mouse over menu counter and indicate
-		// that we should track it.
-		if(hit)
+   if(hit != mouseOverMenu)
+   {
+      //  If we need to, reset the mouse over menu counter and indicate
+      // that we should track it.
+      if(hit)
            mMouseOverCounter = 0;
-		if(!mCountMouseOver)
-		{
+      if(!mCountMouseOver)
+      {
            //  We've never started the counter, so start it.
            if(hit)
               mCountMouseOver = true;
-		}
+      }
 
-		mouseOverMenu = hit;
-		setUpdate();
-	}
+      mouseOverMenu = hit;
+      setUpdate();
+   }
 }
 
 void GuiMenuBar::onMouseLeave(const GuiEvent &event)
 {
    if(mouseOverMenu)
-		setUpdate();
-	mouseOverMenu = NULL;
+      setUpdate();
+   mouseOverMenu = NULL;
 
    //  As we've left the control, don't track how long the mouse has been
    // within it.
    if(mCountMouseOver && mMouseOverCounter >= mMouseHoverAmount)
    {
-	  onMouseInMenu_callback(false); // Last parameter indicates if we've entered or left the menu
+     onMouseInMenu_callback(false); // Last parameter indicates if we've entered or left the menu
    }
    mCountMouseOver = false;
    mMouseOverCounter = 0;
@@ -1259,38 +1259,38 @@ void GuiMenuBar::onMouseLeave(const GuiEvent &event)
 void GuiMenuBar::onMouseDragged(const GuiEvent &event)
 {
    Menu *hit = findHitMenu(event.mousePoint);
-	
-	if(hit != mouseOverMenu)
-	{
-		//  If we need to, reset the mouse over menu counter and indicate
-		// that we should track it.
-		if(hit)
+   
+   if(hit != mouseOverMenu)
+   {
+      //  If we need to, reset the mouse over menu counter and indicate
+      // that we should track it.
+      if(hit)
            mMouseOverCounter = 0;
-		if(!mCountMouseOver)
-		{
+      if(!mCountMouseOver)
+      {
            //  We've never started the counter, so start it.
            if(hit)
               mCountMouseOver = true;
-		}
+      }
 
-		mouseOverMenu = hit;
+      mouseOverMenu = hit;
       mouseDownMenu = hit;
-		setUpdate();
+      setUpdate();
       onAction();
-	}
+   }
 }
 
 void GuiMenuBar::onMouseDown(const GuiEvent &event)
 {
    mouseDownMenu = mouseOverMenu = findHitMenu(event.mousePoint);
-	setUpdate();
+   setUpdate();
    onAction();
 }
 
 void GuiMenuBar::onMouseUp(const GuiEvent &event)
 {
    mouseDownMenu = NULL;
-	setUpdate();
+   setUpdate();
 }
 
 void GuiMenuBar::onRender(Point2I offset, const RectI &updateRect)
@@ -1320,20 +1320,20 @@ void GuiMenuBar::onRender(Point2I offset, const RectI &updateRect)
       start.x = mMenuList[i]->bounds.point.x + mHorizontalMargin;
       start.y = mMenuList[i]->bounds.point.y + (mMenuList[i]->bounds.extent.y - mProfile->mFont->getHeight()) / 2;
 
-	  // Draw the border
+     // Draw the border
       if (mMenuList[i]->drawBorder)
-	  {
+     {
         RectI highlightBounds = bounds;
         highlightBounds.inset(1,1);
         if (mMenuList[i] == mouseDownMenu)
             renderFilledBorder(highlightBounds, mProfile->mBorderColorHL, mProfile->mFillColorHL );
         else if (mMenuList[i] == mouseOverMenu && mouseDownMenu == NULL)
            renderFilledBorder(highlightBounds, mProfile->mBorderColorHL, mProfile->mFillColorHL);
-	  }
+     }
 
-	  // Do we draw a bitmap?
+     // Do we draw a bitmap?
       if (mMenuList[i]->bitmapIndex != -1)
-	  {
+     {
         S32 index = mMenuList[i]->bitmapIndex * 3;
         if (mMenuList[i] == mouseDownMenu)
             ++index;
@@ -1342,24 +1342,24 @@ void GuiMenuBar::onRender(Point2I offset, const RectI &updateRect)
 
          RectI rect = mProfile->mBitmapArrayRects[index];
 
-		 Point2I bitmapstart(start);
+       Point2I bitmapstart(start);
        bitmapstart.y = mMenuList[i]->bounds.point.y + (mMenuList[i]->bounds.extent.y - rect.extent.y) / 2;
 
          drawUtil->clearBitmapModulation();
          drawUtil->drawBitmapSR( mProfile->mTextureObject, offset + bitmapstart, rect);
 
-		 // Should we also draw the text?
+       // Should we also draw the text?
          if (!mMenuList[i]->drawBitmapOnly)
-		 {
+       {
             start.x += mBitmapMargin;
       drawUtil->setBitmapModulation( fontColor );
       drawUtil->drawText(mProfile->mFont, start + offset, mMenuList[i]->text, mProfile->mFontColors);
-		 }
-	  } else
-	  {
+       }
+     } else
+     {
       drawUtil->setBitmapModulation( fontColor );
       drawUtil->drawText(mProfile->mFont, start + offset, mMenuList[i]->text, mProfile->mFontColors);
-	  }
+     }
    }
 
    renderChildControls( offset, updateRect );
@@ -1381,7 +1381,7 @@ void GuiMenuBar::buildWindowAcceleratorMap( WindowInputGenerator &inputGenerator
             continue;
          }
          EventDescriptor accelEvent;
-		 ActionMap::createEventDescriptor(item->accelerator, &accelEvent);
+       ActionMap::createEventDescriptor(item->accelerator, &accelEvent);
    
          //now we have a modifier, and a key, add them to the canvas
          inputGenerator.addAcceleratorKey( this, item->cmd, accelEvent.eventCode, accelEvent.flags);
@@ -1412,7 +1412,7 @@ void GuiMenuBar::acceleratorKeyPress(U32 index)
          {
             // first, call the script callback for menu selection:
             onMenuSelect_callback(mMenuList[i]->id, mMenuList[i]->text);
-			
+         
             if(item->visible)
                menuItemSelected(mMenuList[i], item);
             return;
@@ -1551,15 +1551,15 @@ void GuiMenuTextListCtrl::onMouseUp(const GuiEvent &event)
 
 void GuiMenuTextListCtrl::onCellHighlighted(Point2I cell)
 {
-	// If this text list control is part of a submenu, then don't worry about
-	// passing this along
-	if(!isSubMenu)
-	{
-		RectI globalbounds(getBounds());
-		Point2I globalpoint = localToGlobalCoord(globalbounds.point);
-		globalbounds.point = globalpoint;
-		mMenuBarCtrl->highlightedMenuItem(cell.y, globalbounds, mCellSize);
-	}
+   // If this text list control is part of a submenu, then don't worry about
+   // passing this along
+   if(!isSubMenu)
+   {
+      RectI globalbounds(getBounds());
+      Point2I globalpoint = localToGlobalCoord(globalbounds.point);
+      globalbounds.point = globalpoint;
+      mMenuBarCtrl->highlightedMenuItem(cell.y, globalbounds, mCellSize);
+   }
 }
 
 //------------------------------------------------------------------------------
@@ -1582,9 +1582,9 @@ bool GuiSubmenuBackgroundCtrl::pointInControl(const Point2I& parentCoordPoint)
    S32 yt = parentCoordPoint.y - getTop();
 
    if(findHitControl(Point2I(xt,yt)) == this)
-	   return false;
+      return false;
    else
-	   return true;
+      return true;
 //   return xt >= 0 && yt >= 0 && xt < getWidth() && yt < getHeight();
 }
 
@@ -1609,7 +1609,7 @@ void GuiMenuBar::onSleep()
 void GuiMenuBar::closeMenu()
 {
    //  First close any open submenu
-	closeSubmenu();
+   closeSubmenu();
 
    // Get the selection from the text list:
    S32 selectionIndex = mTextList->getSelectedCell().y;
@@ -1657,25 +1657,25 @@ void GuiMenuBar::highlightedMenuItem(S32 selectionIndex, const RectI& bounds, Po
       }
 
       if(list)
-	  {
+     {
          // If the highlighted item has changed...
          if(mouseOverSubmenu != list)
-		 {
+       {
             closeSubmenu();
             mouseOverSubmenu = NULL;
 
             // Check if this is a submenu.  If so, open the submenu.
             if(list->isSubmenu)
-		    {
-			   // If there are submenu items, then open the submenu
+          {
+            // If there are submenu items, then open the submenu
              if(list->submenu->firstMenuItem)
-			   {
-				   mouseOverSubmenu = list;
-				   onSubmenuAction(selstore, bounds, cellSize);
-			   }
-			}
-		 }
-	  }
+            {
+               mouseOverSubmenu = list;
+               onSubmenuAction(selstore, bounds, cellSize);
+            }
+         }
+       }
+     }
    }
 }
 
@@ -1745,11 +1745,11 @@ void GuiMenuBar::onAction()
 
       char buf[512];
 
-	  //  If this menu item is a submenu, then set the isSubmenu to 2 to indicate
-	  // an arrow should be drawn.  Otherwise set the isSubmenu normally.
-	  char isSubmenu = 1;
-	  if(walk->isSubmenu)
-		  isSubmenu = 2;
+     //  If this menu item is a submenu, then set the isSubmenu to 2 to indicate
+     // an arrow should be drawn.  Otherwise set the isSubmenu normally.
+     char isSubmenu = 1;
+     if(walk->isSubmenu)
+        isSubmenu = 2;
 
       char bitmapIndex = 1;
       if(walk->bitmapIndex >= 0 && (walk->bitmapIndex * 3 <= mProfile->mBitmapArrayRects.size()))
@@ -1861,8 +1861,8 @@ void GuiMenuBar::onSubmenuAction(S32 selectionIndex, const RectI& bounds, Point2
 
       char buf[512];
 
-	  //  Can't have submenus within submenus.
-	  char isSubmenu = 1;
+     //  Can't have submenus within submenus.
+     char isSubmenu = 1;
 
       char bitmapIndex = 1;
       if(walk->bitmapIndex >= 0 && (walk->bitmapIndex * 3 <= mProfile->mBitmapArrayRects.size()))
@@ -1916,7 +1916,7 @@ void GuiMenuBar::onSubmenuAction(S32 selectionIndex, const RectI& bounds, Point2
 void GuiMenuBar::closeSubmenu()
 {
    if(!mSubmenuBackground || !mSubmenuTextList)
-	   return;
+      return;
 
    // Get the selection from the text list:
    S32 selectionIndex = mSubmenuTextList->getSelectedCell().y;
@@ -1934,8 +1934,8 @@ void GuiMenuBar::closeSubmenu()
    if ( selectionIndex != -1 )
    {
       MenuItem *list = NULL;
-	  if(mouseOverSubmenu)
-	  {
+     if(mouseOverSubmenu)
+     {
          list = mouseOverSubmenu->submenu->firstMenuItem;
 
          while(selectionIndex && list)
@@ -1943,7 +1943,7 @@ void GuiMenuBar::closeSubmenu()
             list = list->nextMenuItem;
             selectionIndex--;
          }
-	  }
+     }
       if(list)
          menuItemSelected(list->submenuParentMenu, list);
    }
@@ -1981,13 +1981,13 @@ void GuiMenuBar::processTick()
    {
       //  If we're at a particular number of ticks, notify the script function
       if(mMouseOverCounter < mMouseHoverAmount)
-	  {
+     {
          ++mMouseOverCounter;
 
-	  } else if(mMouseOverCounter == mMouseHoverAmount)
-	  {
+     } else if(mMouseOverCounter == mMouseHoverAmount)
+     {
          ++mMouseOverCounter;
-		 onMouseInMenu_callback(true); // Last parameter indicates if we've entered or left the menu
-	  }
+       onMouseInMenu_callback(true); // Last parameter indicates if we've entered or left the menu
+     }
    }
 }

Engine/source/lighting/lightManager.cpp

@@ -306,7 +306,7 @@ void LightManager::_update4LightConsts(   const SceneData &sgData,
                                           GFXShaderConstHandle *lightInvRadiusSqSC,
                                           GFXShaderConstHandle *lightSpotDirSC,
                                           GFXShaderConstHandle *lightSpotAngleSC,
-										  GFXShaderConstHandle *lightSpotFalloffSC,
+                                GFXShaderConstHandle *lightSpotFalloffSC,
                                           GFXShaderConstBuffer *shaderConsts )
 {
    PROFILE_SCOPE( LightManager_Update4LightConsts );
@@ -317,7 +317,7 @@ void LightManager::_update4LightConsts(   const SceneData &sgData,
          lightInvRadiusSqSC->isValid() ||
          lightSpotDirSC->isValid() ||
          lightSpotAngleSC->isValid() ||
-		 lightSpotFalloffSC->isValid() )
+       lightSpotFalloffSC->isValid() )
    {
       PROFILE_SCOPE( LightManager_Update4LightConsts_setLights );
 
@@ -326,7 +326,7 @@ void LightManager::_update4LightConsts(   const SceneData &sgData,
       static AlignedArray<Point4F> lightColors( 4, sizeof( Point4F ) );
       static Point4F lightInvRadiusSq;
       static Point4F lightSpotAngle;
-	  static Point4F lightSpotFalloff;
+     static Point4F lightSpotFalloff;
       F32 range;
       
       // Need to clear the buffers so that we don't leak
@@ -359,10 +359,10 @@ void LightManager::_update4LightConsts(   const SceneData &sgData,
             lightSpotDirs[2][i] = lightDir.z;
             
             if ( light->getType() == LightInfo::Spot )
-			{
+         {
                lightSpotAngle[i] = mCos( mDegToRad( light->getOuterConeAngle() / 2.0f ) ); 
-			   lightSpotFalloff[i] = 1.0f / getMax( F32_MIN, mCos( mDegToRad( light->getInnerConeAngle() / 2.0f ) ) - lightSpotAngle[i] );
-			}
+            lightSpotFalloff[i] = 1.0f / getMax( F32_MIN, mCos( mDegToRad( light->getInnerConeAngle() / 2.0f ) ) - lightSpotAngle[i] );
+         }
 
          // Prescale the light color by the brightness to 
          // avoid doing this in the shader.
@@ -379,7 +379,7 @@ void LightManager::_update4LightConsts(   const SceneData &sgData,
 
          shaderConsts->setSafe( lightSpotDirSC, lightSpotDirs );
          shaderConsts->setSafe( lightSpotAngleSC, lightSpotAngle );
-		 shaderConsts->setSafe( lightSpotFalloffSC, lightSpotFalloff );
+       shaderConsts->setSafe( lightSpotFalloffSC, lightSpotFalloff );
 
       
    }
@@ -442,7 +442,7 @@ DefineEngineFunction( setLightManager, bool, ( const char *name ),,
    return gClientSceneGraph->setLightManager( name );
 }
 
-DefineEngineFunction( lightScene, bool, ( const char *completeCallbackFn, const char *mode ), ( NULL, NULL ),
+DefineEngineFunction( lightScene, bool, ( const char *completeCallbackFn, const char *mode ), ( nullAsType<const char*>(), nullAsType<const char*>() ),
    "Will generate static lighting for the scene if supported by the active light manager.\n\n"
    "If mode is \"forceAlways\", the lightmaps will be regenerated regardless of whether "
    "lighting cache files can be written to. If mode is \"forceWritable\", then the lightmaps "

Engine/source/scene/sceneContainer.cpp

@@ -892,7 +892,7 @@ bool SceneContainer::_castRay( U32 type, const Point3F& start, const Point3F& en
                   *info = ri;
                   info->point.interpolate(start, end, info->t);
                   currentT = ri.t;
-						info->distance = (start - info->point).len();
+                  info->distance = (start - info->point).len();
                }
             }
          }
@@ -991,7 +991,7 @@ bool SceneContainer::_castRay( U32 type, const Point3F& start, const Point3F& en
                            *info = ri;
                            info->point.interpolate(start, end, info->t);
                            currentT = ri.t;
-						         info->distance = (start - info->point).len();
+                           info->distance = (start - info->point).len();
                         }
                      }
                   }
@@ -1088,7 +1088,7 @@ bool SceneContainer::_castRay( U32 type, const Point3F& start, const Point3F& en
                                  *info = ri;
                                  info->point.interpolate(start, end, info->t);
                                  currentT = ri.t;
-								         info->distance = (start - info->point).len();
+                                 info->distance = (start - info->point).len();
                               }
                            }
                         }
@@ -1602,7 +1602,7 @@ DefineEngineFunction( containerSearchCurrRadiusDist, F32, ( bool useClientContai
 
 //TODO: make RayInfo an API type
 DefineEngineFunction( containerRayCast, const char*,
-   ( Point3F start, Point3F end, U32 mask, SceneObject *pExempt, bool useClientContainer ), ( NULL, false ),
+   ( Point3F start, Point3F end, U32 mask, SceneObject *pExempt, bool useClientContainer ), ( nullAsType<SceneObject*>(), false ),
    "@brief Cast a ray from start to end, checking for collision against items matching mask.\n\n"
 
    "If pExempt is specified, then it is temporarily excluded from collision checks (For "

Engine/source/sim/actionMap.cpp

@@ -36,138 +36,138 @@
 IMPLEMENT_CONOBJECT(ActionMap);
 
 ConsoleDocClass( ActionMap,
-	"@brief ActionMaps assign platform input events to console commands.\n\n"
-
-	"Any platform input event can be bound in a single, generic way. In theory, the game doesn't need to know if the event came from the keyboard, mouse, joystick "
-	"or some other input device. This allows users of the game to map keys and actions according to their own preferences. "
-	"Game action maps are arranged in a stack for processing so individual parts of the game can define specific "
-	"actions. For example, when the player jumps into a vehicle it could push a vehicle action map and pop the default player action map.\n\n"
-
-	"@section ActionMap_creation Creating an ActionMap\n"
-
-	"The input system allows for the creation of multiple ActionMaps, so long as they have unique names and do not already exist. It's a simple "
-	"three step process.\n\n"
-	"1. Check to see if the ActionMap exists\n"
-	"2. Delete it if it exists\n"
-	"3. Instantiate the ActionMap\n\n"
-
-	"The following is an example of how to create a new ActionMap:\n"
-
-	"@tsexample\n"
-	"if ( isObject( moveMap ) )\n"
-	"	moveMap.delete();\n"
-	"new ActionMap(moveMap);"
-	"@endtsexample\n\n\n"
-	
-	"@section ActionMap_binding Binding Functions\n"
-	"Once you have created an ActionMap, you can start binding functionality to events. Currently, Torque 3D supports the following devices out of the box\n\n"
-	"* Mouse\n\n"
-	"* Keyboard\n\n"
-	"* Joystick/Gamepad\n\n"
-	"* Xbox 360 Controller\n\n"
-
-	"The two most commonly used binding methods are bind() and bindCmd(). Both are similar in that they will bind functionality to a device and event, "
+   "@brief ActionMaps assign platform input events to console commands.\n\n"
+
+   "Any platform input event can be bound in a single, generic way. In theory, the game doesn't need to know if the event came from the keyboard, mouse, joystick "
+   "or some other input device. This allows users of the game to map keys and actions according to their own preferences. "
+   "Game action maps are arranged in a stack for processing so individual parts of the game can define specific "
+   "actions. For example, when the player jumps into a vehicle it could push a vehicle action map and pop the default player action map.\n\n"
+
+   "@section ActionMap_creation Creating an ActionMap\n"
+
+   "The input system allows for the creation of multiple ActionMaps, so long as they have unique names and do not already exist. It's a simple "
+   "three step process.\n\n"
+   "1. Check to see if the ActionMap exists\n"
+   "2. Delete it if it exists\n"
+   "3. Instantiate the ActionMap\n\n"
+
+   "The following is an example of how to create a new ActionMap:\n"
+
+   "@tsexample\n"
+   "if ( isObject( moveMap ) )\n"
+   "  moveMap.delete();\n"
+   "new ActionMap(moveMap);"
+   "@endtsexample\n\n\n"
+   
+   "@section ActionMap_binding Binding Functions\n"
+   "Once you have created an ActionMap, you can start binding functionality to events. Currently, Torque 3D supports the following devices out of the box\n\n"
+   "* Mouse\n\n"
+   "* Keyboard\n\n"
+   "* Joystick/Gamepad\n\n"
+   "* Xbox 360 Controller\n\n"
+
+   "The two most commonly used binding methods are bind() and bindCmd(). Both are similar in that they will bind functionality to a device and event, "
    "but different in how the event is interpreted. With bind(), "
-	"you specify a device, action to bind, then a function to be called when the event happens.\n\n"
-
-	"@tsexample\n"
-	"// Simple function that prints to console\n"
-	"// %val - Sent by the device letting the user know\n"
-	"// if an input was pressed (true) or released (false)\n"
-	"function testInput(%val)\n"
-	"{\n"
-	"   if(%val)\n"
-	"	  echo(\"Key is down\");\n"
-	"   else\n"
-	"	  echo(\"Key was released\");\n"
-	"}\n\n"
-	"// Bind the \'K\' key to the testInput function\n"
-	"moveMap.bind(keyboard, \"k\", testInput);\n\n"
-	"@endtsexample\n\n\n"
-
-	"bindCmd is an alternative method for binding commands. This function is similar to bind(), "
+   "you specify a device, action to bind, then a function to be called when the event happens.\n\n"
+
+   "@tsexample\n"
+   "// Simple function that prints to console\n"
+   "// %val - Sent by the device letting the user know\n"
+   "// if an input was pressed (true) or released (false)\n"
+   "function testInput(%val)\n"
+   "{\n"
+   "   if(%val)\n"
+   "    echo(\"Key is down\");\n"
+   "   else\n"
+   "    echo(\"Key was released\");\n"
+   "}\n\n"
+   "// Bind the \'K\' key to the testInput function\n"
+   "moveMap.bind(keyboard, \"k\", testInput);\n\n"
+   "@endtsexample\n\n\n"
+
+   "bindCmd is an alternative method for binding commands. This function is similar to bind(), "
    "except two functions are set to be called when the event is processed.\n\n"
-	"One will be called when the event is activated (input down), while the other is activated when the event is broken (input release). "
+   "One will be called when the event is activated (input down), while the other is activated when the event is broken (input release). "
    "When using bindCmd(), pass the functions as strings rather than the function names.\n\n"
 
-	"@tsexample\n"
-	"// Print to the console when the spacebar is pressed\n"
-	"function onSpaceDown()\n"
-	"{\n"
-	"   echo(\"Space bar down!\");\n"
-	"}\n\n"
-
-	"// Print to the console when the spacebar is released\n"
-	"function onSpaceUp()\n"
-	"{\n"
-	"   echo(\"Space bar up!\");\n"
-	"}\n\n"
-
-	"// Bind the commands onSpaceDown and onSpaceUp to spacebar events\n"
-	"moveMap.bindCmd(keyboard, \"space\", \"onSpaceDown();\", \"onSpaceUp();\");\n"
-	"@endtsexample\n\n"
-	
-	"@section ActionMap_switching Switching ActionMaps\n"
-	"Let's say you want to have different ActionMaps activated based on game play situations. A classic example would be first person shooter controls and racing controls "
-	"in the same game. On foot, spacebar may cause your player to jump. In a vehicle, it may cause some kind of \"turbo charge\". You simply need to push/pop the ActionMaps appropriately:\n\n"
-
-	"First, create two separate ActionMaps:\n\n"
-	"@tsexample\n"
-	"// Create the two ActionMaps\n"
-	"if ( isObject( moveMap ) )\n"
-	"	moveMap.delete();\n"
-	"new ActionMap(moveMap);\n\n"
-	"if ( isObject( carMap ) )\n"
-	"	carMap.delete();\n"
-	"new ActionMap(carMap);\n\n"
-	"@endtsexample\n\n"
-
-	"Next, create the two separate functions. Both will be bound to spacebar, but not the same ActionMap:\n\n"
-	"@tsexample\n"
-	"// Print to the console the player is jumping\n"
-	"function playerJump(%val)\n"
-	"{\n"
-	"   if(%val)\n"
-	"	  echo(\"Player jumping!\");\n"
-	"}\n\n"
-	"// Print to the console the vehicle is charging\n"
-	"function turboCharge()\n"
-	"{\n"
-	"   if(%val)\n"
-	"	  echo(\"Vehicle turbo charging!\");\n"
-	"}\n"
-	"@endtsexample\n\n"
-	
-	"You are now ready to bind functions to your ActionMaps' devices:\n\n"
-
-	"@tsexample\n"
-	"// Bind the spacebar to the playerJump function\n"
-	"// when moveMap is the active ActionMap\n"
-	"moveMap.bind(keyboard, \"space\", playerJump);\n\n"
-	"// Bind the spacebar to the turboCharge function\n"
-	"// when carMap is the active ActionMap\n"
-	"carMap.bind(keyboard, \"space\", turboCharge);\n"
-	"@endtsexample\n"
-
-	"Finally, you can use the push() and pop() commands on each ActionMap to toggle activation. To activate an ActionMap, use push():\n\n"
-
-	"@tsexample\n"
-	"// Make moveMap the active action map\n"
-	"// You should now be able to activate playerJump with spacebar\n"
-	"moveMap.push();\n"
-	"@endtsexample\n\n"
-
-	"To switch ActionMaps, first pop() the old one. Then you can push() the new one:\n\n"
-
-	"@tsexample\n"
-	"// Deactivate moveMap\n"
-	"moveMap.pop();\n\n"
-	"// Activate carMap\n"
-	"carMap.push();\n\n"
-	"@endtsexample\n\n\n"
-
-	"@ingroup Input"
-	
+   "@tsexample\n"
+   "// Print to the console when the spacebar is pressed\n"
+   "function onSpaceDown()\n"
+   "{\n"
+   "   echo(\"Space bar down!\");\n"
+   "}\n\n"
+
+   "// Print to the console when the spacebar is released\n"
+   "function onSpaceUp()\n"
+   "{\n"
+   "   echo(\"Space bar up!\");\n"
+   "}\n\n"
+
+   "// Bind the commands onSpaceDown and onSpaceUp to spacebar events\n"
+   "moveMap.bindCmd(keyboard, \"space\", \"onSpaceDown();\", \"onSpaceUp();\");\n"
+   "@endtsexample\n\n"
+   
+   "@section ActionMap_switching Switching ActionMaps\n"
+   "Let's say you want to have different ActionMaps activated based on game play situations. A classic example would be first person shooter controls and racing controls "
+   "in the same game. On foot, spacebar may cause your player to jump. In a vehicle, it may cause some kind of \"turbo charge\". You simply need to push/pop the ActionMaps appropriately:\n\n"
+
+   "First, create two separate ActionMaps:\n\n"
+   "@tsexample\n"
+   "// Create the two ActionMaps\n"
+   "if ( isObject( moveMap ) )\n"
+   "  moveMap.delete();\n"
+   "new ActionMap(moveMap);\n\n"
+   "if ( isObject( carMap ) )\n"
+   "  carMap.delete();\n"
+   "new ActionMap(carMap);\n\n"
+   "@endtsexample\n\n"
+
+   "Next, create the two separate functions. Both will be bound to spacebar, but not the same ActionMap:\n\n"
+   "@tsexample\n"
+   "// Print to the console the player is jumping\n"
+   "function playerJump(%val)\n"
+   "{\n"
+   "   if(%val)\n"
+   "    echo(\"Player jumping!\");\n"
+   "}\n\n"
+   "// Print to the console the vehicle is charging\n"
+   "function turboCharge()\n"
+   "{\n"
+   "   if(%val)\n"
+   "    echo(\"Vehicle turbo charging!\");\n"
+   "}\n"
+   "@endtsexample\n\n"
+   
+   "You are now ready to bind functions to your ActionMaps' devices:\n\n"
+
+   "@tsexample\n"
+   "// Bind the spacebar to the playerJump function\n"
+   "// when moveMap is the active ActionMap\n"
+   "moveMap.bind(keyboard, \"space\", playerJump);\n\n"
+   "// Bind the spacebar to the turboCharge function\n"
+   "// when carMap is the active ActionMap\n"
+   "carMap.bind(keyboard, \"space\", turboCharge);\n"
+   "@endtsexample\n"
+
+   "Finally, you can use the push() and pop() commands on each ActionMap to toggle activation. To activate an ActionMap, use push():\n\n"
+
+   "@tsexample\n"
+   "// Make moveMap the active action map\n"
+   "// You should now be able to activate playerJump with spacebar\n"
+   "moveMap.push();\n"
+   "@endtsexample\n\n"
+
+   "To switch ActionMaps, first pop() the old one. Then you can push() the new one:\n\n"
+
+   "@tsexample\n"
+   "// Deactivate moveMap\n"
+   "moveMap.pop();\n\n"
+   "// Activate carMap\n"
+   "carMap.push();\n\n"
+   "@endtsexample\n\n\n"
+
+   "@ingroup Input"
+   
 );
 
 // This is used for determing keys that have ascii codes for the foreign keyboards. IsAlpha doesn't work on foreign keys.
@@ -775,32 +775,32 @@ const char* ActionMap::getBinding( const char* command )
 //
 const char* ActionMap::getCommand( const char* device, const char* action )
 {
-	U32 deviceType;
-	U32 deviceInst;
-	if ( getDeviceTypeAndInstance( device, deviceType, deviceInst ) )
-	{
-		EventDescriptor eventDescriptor;
-		if ( createEventDescriptor( action, &eventDescriptor ) )
-		{
-			const ActionMap::Node* mapNode = findNode( deviceType, deviceInst, eventDescriptor.flags, eventDescriptor.eventCode );
-			if ( mapNode )
-			{
-				if ( mapNode->flags & Node::BindCmd )
-				{
-					S32 bufferLen = dStrlen( mapNode->makeConsoleCommand ) + dStrlen( mapNode->breakConsoleCommand ) + 2;
-					char* returnString = Con::getReturnBuffer( bufferLen );
-					dSprintf( returnString, bufferLen, "%s\t%s",
-							( mapNode->makeConsoleCommand ? mapNode->makeConsoleCommand : "" ),
-							( mapNode->breakConsoleCommand ? mapNode->breakConsoleCommand : "" ) );					
-					return( returnString );
-				}					
-				else
-					return( mapNode->consoleFunction );					
-			}
-		}
-	}
-
-	return( "" );
+   U32 deviceType;
+   U32 deviceInst;
+   if ( getDeviceTypeAndInstance( device, deviceType, deviceInst ) )
+   {
+      EventDescriptor eventDescriptor;
+      if ( createEventDescriptor( action, &eventDescriptor ) )
+      {
+         const ActionMap::Node* mapNode = findNode( deviceType, deviceInst, eventDescriptor.flags, eventDescriptor.eventCode );
+         if ( mapNode )
+         {
+            if ( mapNode->flags & Node::BindCmd )
+            {
+               S32 bufferLen = dStrlen( mapNode->makeConsoleCommand ) + dStrlen( mapNode->breakConsoleCommand ) + 2;
+               char* returnString = Con::getReturnBuffer( bufferLen );
+               dSprintf( returnString, bufferLen, "%s\t%s",
+                     ( mapNode->makeConsoleCommand ? mapNode->makeConsoleCommand : "" ),
+                     ( mapNode->breakConsoleCommand ? mapNode->breakConsoleCommand : "" ) );             
+               return( returnString );
+            }              
+            else
+               return( mapNode->consoleFunction );             
+         }
+      }
+   }
+
+   return( "" );
 }
 
 //------------------------------------------------------------------------------
@@ -808,92 +808,92 @@ const char* ActionMap::getCommand( const char* device, const char* action )
 // Obviously, this should only be used for axes.
 bool ActionMap::isInverted( const char* device, const char* action )
 {
-	U32 deviceType;
-	U32 deviceInst;
-	if ( getDeviceTypeAndInstance( device, deviceType, deviceInst ) )
-	{
-		EventDescriptor eventDescriptor;
-		if ( createEventDescriptor( action, &eventDescriptor ) )
-		{
-			const ActionMap::Node* mapNode = findNode( deviceType, deviceInst, eventDescriptor.flags, eventDescriptor.eventCode );
-			if ( mapNode )
-				return( mapNode->flags & Node::Inverted );
-		}
-	}
-
-	Con::errorf( "The input event specified by %s %s is not in this action map!", device, action );
-	return( false );
+   U32 deviceType;
+   U32 deviceInst;
+   if ( getDeviceTypeAndInstance( device, deviceType, deviceInst ) )
+   {
+      EventDescriptor eventDescriptor;
+      if ( createEventDescriptor( action, &eventDescriptor ) )
+      {
+         const ActionMap::Node* mapNode = findNode( deviceType, deviceInst, eventDescriptor.flags, eventDescriptor.eventCode );
+         if ( mapNode )
+            return( mapNode->flags & Node::Inverted );
+      }
+   }
+
+   Con::errorf( "The input event specified by %s %s is not in this action map!", device, action );
+   return( false );
 }
 
 //------------------------------------------------------------------------------
 F32 ActionMap::getScale( const char* device, const char* action )
 {
-	U32 deviceType;
-	U32 deviceInst;
-	if ( getDeviceTypeAndInstance( device, deviceType, deviceInst ) )
-	{
-		EventDescriptor eventDescriptor;
-		if ( createEventDescriptor( action, &eventDescriptor ) )
-		{
-			const ActionMap::Node* mapNode = findNode( deviceType, deviceInst, eventDescriptor.flags, eventDescriptor.eventCode );
-			if ( mapNode )
-			{
-			   if ( mapNode->flags & Node::HasScale )
-				   return( mapNode->scaleFactor );
+   U32 deviceType;
+   U32 deviceInst;
+   if ( getDeviceTypeAndInstance( device, deviceType, deviceInst ) )
+   {
+      EventDescriptor eventDescriptor;
+      if ( createEventDescriptor( action, &eventDescriptor ) )
+      {
+         const ActionMap::Node* mapNode = findNode( deviceType, deviceInst, eventDescriptor.flags, eventDescriptor.eventCode );
+         if ( mapNode )
+         {
+            if ( mapNode->flags & Node::HasScale )
+               return( mapNode->scaleFactor );
             else
                return( 1.0f );
          }
-		}
-	}
+      }
+   }
 
-	Con::errorf( "The input event specified by %s %s is not in this action map!", device, action );
-	return( 1.0f );
+   Con::errorf( "The input event specified by %s %s is not in this action map!", device, action );
+   return( 1.0f );
 }
 
 //------------------------------------------------------------------------------
 const char* ActionMap::getDeadZone( const char* device, const char* action )
 {
-	U32 deviceType;
-	U32 deviceInst;
-	if ( getDeviceTypeAndInstance( device, deviceType, deviceInst ) )
-	{
-		EventDescriptor eventDescriptor;
-		if ( createEventDescriptor( action, &eventDescriptor ) )
-		{
-			const ActionMap::Node* mapNode = findNode( deviceType, deviceInst, eventDescriptor.flags, eventDescriptor.eventCode );
-			if ( mapNode )
-			{
-			   if ( mapNode->flags & Node::HasDeadZone )
+   U32 deviceType;
+   U32 deviceInst;
+   if ( getDeviceTypeAndInstance( device, deviceType, deviceInst ) )
+   {
+      EventDescriptor eventDescriptor;
+      if ( createEventDescriptor( action, &eventDescriptor ) )
+      {
+         const ActionMap::Node* mapNode = findNode( deviceType, deviceInst, eventDescriptor.flags, eventDescriptor.eventCode );
+         if ( mapNode )
+         {
+            if ( mapNode->flags & Node::HasDeadZone )
             {
-				   char buf[64];
-				   dSprintf( buf, sizeof( buf ), "%g %g", mapNode->deadZoneBegin, mapNode->deadZoneEnd );
-				   char* returnString = Con::getReturnBuffer( dStrlen( buf ) + 1 );
-				   dStrcpy( returnString, buf );
-				   return( returnString );
-				}
-				else
-				   return( "0 0" );				   		
-			}
-		}
-	}
-
-	Con::errorf( "The input event specified by %s %s is not in this action map!", device, action );
-	return( "" );
+               char buf[64];
+               dSprintf( buf, sizeof( buf ), "%g %g", mapNode->deadZoneBegin, mapNode->deadZoneEnd );
+               char* returnString = Con::getReturnBuffer( dStrlen( buf ) + 1 );
+               dStrcpy( returnString, buf );
+               return( returnString );
+            }
+            else
+               return( "0 0" );                    
+         }
+      }
+   }
+
+   Con::errorf( "The input event specified by %s %s is not in this action map!", device, action );
+   return( "" );
 }
 
 //------------------------------------------------------------------------------
 const char* ActionMap::buildActionString( const InputEventInfo* event )
 {
-	const char* modifierString = getModifierString( event->modifier );
+   const char* modifierString = getModifierString( event->modifier );
 
-	char objectBuffer[64];
-	if ( !getKeyString( event->objInst, objectBuffer ) )
-		return( "" );
+   char objectBuffer[64];
+   if ( !getKeyString( event->objInst, objectBuffer ) )
+      return( "" );
 
-	U32 returnLen = dStrlen( modifierString ) + dStrlen( objectBuffer ) + 2;	
-	char* returnString = Con::getReturnBuffer( returnLen );
-	dSprintf( returnString, returnLen - 1, "%s%s", modifierString, objectBuffer );
-	return( returnString );
+   U32 returnLen = dStrlen( modifierString ) + dStrlen( objectBuffer ) + 2;   
+   char* returnString = Con::getReturnBuffer( returnLen );
+   dSprintf( returnString, returnLen - 1, "%s%s", modifierString, objectBuffer );
+   return( returnString );
 }
 
 //------------------------------------------------------------------------------
@@ -989,15 +989,15 @@ bool ActionMap::getDeviceName(const U32 deviceType, const U32 deviceInstance, ch
 //------------------------------------------------------------------------------
 const char* ActionMap::getModifierString(const U32 modifiers)
 {
-	U32 realModifiers = modifiers;
-	if ( modifiers & SI_LSHIFT || modifiers & SI_RSHIFT )
-		realModifiers |= SI_SHIFT;
-	if ( modifiers & SI_LCTRL || modifiers & SI_RCTRL )
-		realModifiers |= SI_CTRL;
-	if ( modifiers & SI_LALT || modifiers & SI_RALT )
-		realModifiers |= SI_ALT;
-	if ( modifiers & SI_MAC_LOPT || modifiers & SI_MAC_ROPT )
-		realModifiers |= SI_MAC_OPT;
+   U32 realModifiers = modifiers;
+   if ( modifiers & SI_LSHIFT || modifiers & SI_RSHIFT )
+      realModifiers |= SI_SHIFT;
+   if ( modifiers & SI_LCTRL || modifiers & SI_RCTRL )
+      realModifiers |= SI_CTRL;
+   if ( modifiers & SI_LALT || modifiers & SI_RALT )
+      realModifiers |= SI_ALT;
+   if ( modifiers & SI_MAC_LOPT || modifiers & SI_MAC_ROPT )
+      realModifiers |= SI_MAC_OPT;
 
    switch (realModifiers & (SI_SHIFT|SI_CTRL|SI_ALT|SI_MAC_OPT)) 
    {
@@ -1820,19 +1820,19 @@ static ConsoleDocFragment _ActionMapbind1(
    "@param command The function to bind to the action. Function must have a single boolean argument.\n"
    "@return True if the binding was successful, false if the device was unknown or description failed.\n\n"
    "@tsexample\n"
-	"// Simple function that prints to console\n"
-	"// %val - Sent by the device letting the user know\n"
-	"// if an input was pressed (true) or released (false)\n"
-	"function testInput(%val)\n"
-	"{\n"
-	"   if(%val)\n"
-	"	  echo(\"Key is down\");\n"
-	"   else\n"
-	"	  echo(\"Key was released\");\n"
-	"}\n\n"
-	"// Bind the \'K\' key to the testInput function\n"
-	"moveMap.bind(keyboard, k, testInput);\n\n"
-	"@endtsexample\n\n\n",
+   "// Simple function that prints to console\n"
+   "// %val - Sent by the device letting the user know\n"
+   "// if an input was pressed (true) or released (false)\n"
+   "function testInput(%val)\n"
+   "{\n"
+   "   if(%val)\n"
+   "    echo(\"Key is down\");\n"
+   "   else\n"
+   "    echo(\"Key was released\");\n"
+   "}\n\n"
+   "// Bind the \'K\' key to the testInput function\n"
+   "moveMap.bind(keyboard, k, testInput);\n\n"
+   "@endtsexample\n\n\n",
    "ActionMap",
    "bool bind( string device, string action, string command );");
 
@@ -1854,22 +1854,22 @@ static ConsoleDocFragment _ActionMapbind2(
    "@param command The function bound to the action. Must take in a single argument.\n"
    "@return True if the binding was successful, false if the device was unknown or description failed.\n\n"
    "@tsexample\n"
-	"// Simple function that adjusts the pitch of the camera based on the "
+   "// Simple function that adjusts the pitch of the camera based on the "
    "mouse's movement along the X axis.\n"
-	"function testPitch(%val)\n"
-	"{\n"
-	"   %pitchAdj = getMouseAdjustAmount(%val);\n"
-	"	 $mvPitch += %pitchAdj;\n"
-	"}\n\n"
-	"// Bind the mouse's X axis to the testPitch function\n"
-	"// DI is flagged, meaning input is inverted and has a deadzone\n"
-	"%this.bind( mouse, \"xaxis\", \"DI\", \"-0.23 0.23\", testPitch );\n"
-	"@endtsexample\n\n\n",
+   "function testPitch(%val)\n"
+   "{\n"
+   "   %pitchAdj = getMouseAdjustAmount(%val);\n"
+   "   $mvPitch += %pitchAdj;\n"
+   "}\n\n"
+   "// Bind the mouse's X axis to the testPitch function\n"
+   "// DI is flagged, meaning input is inverted and has a deadzone\n"
+   "%this.bind( mouse, \"xaxis\", \"DI\", \"-0.23 0.23\", testPitch );\n"
+   "@endtsexample\n\n\n",
    "ActionMap",
    "bool bind( string device, string action, string flag, string deadZone, string scale, string command );");
 
 ConsoleMethod( ActionMap, bind, bool, 5, 10, "actionMap.bind( device, action, [modifier spec, mod...], command )" 
-			  "@hide")
+           "@hide")
 {
    StringStackWrapper args(argc - 2, argv + 2);
    return object->processBind( args.count(), args, NULL );
@@ -1918,7 +1918,7 @@ static ConsoleDocFragment _ActionMapbindObj2(
    "bool bindObj( string device, string action, string flag, string deadZone, string scale, string command, SimObjectID object );");
 
 ConsoleMethod( ActionMap, bindObj, bool, 6, 11, "(device, action, [modifier spec, mod...], command, object)"
-			  "@hide")
+           "@hide")
 {
    SimObject* simObject = Sim::findObject(argv[argc - 1]);
    if ( simObject == NULL )
@@ -1941,20 +1941,20 @@ DefineEngineMethod( ActionMap, bindCmd, bool, ( const char* device, const char*
     "@param makeCmd The command to execute when the device/action is made.\n"
     "@param breakCmd [optional] The command to execute when the device or action is unmade.\n"
     "@return True the bind was successful, false if the device was unknown or description failed.\n"
-	"@tsexample\n"
-	"// Print to the console when the spacebar is pressed\n"
-	"function onSpaceDown()\n"
-	"{\n"
-	"   echo(\"Space bar down!\");\n"
-	"}\n\n"
-	"// Print to the console when the spacebar is released\n"
-	"function onSpaceUp()\n"
-	"{\n"
-	"   echo(\"Space bar up!\");\n"
-	"}\n\n"
+   "@tsexample\n"
+   "// Print to the console when the spacebar is pressed\n"
+   "function onSpaceDown()\n"
+   "{\n"
+   "   echo(\"Space bar down!\");\n"
+   "}\n\n"
+   "// Print to the console when the spacebar is released\n"
+   "function onSpaceUp()\n"
+   "{\n"
+   "   echo(\"Space bar up!\");\n"
+   "}\n\n"
    "// Bind the commands onSpaceDown() and onSpaceUp() to spacebar events\n\n"
-	"moveMap.bindCmd(keyboard, \"space\", \"onSpaceDown();\", \"onSpaceUp();\");\n"
-	"@endtsexample\n\n")
+   "moveMap.bindCmd(keyboard, \"space\", \"onSpaceDown();\", \"onSpaceUp();\");\n"
+   "@endtsexample\n\n")
 {
    return object->processBindCmd( device, action, makeCmd, breakCmd );
 }
@@ -1964,9 +1964,9 @@ DefineEngineMethod( ActionMap, unbind, bool, ( const char* device, const char* a
    "@param device The device to unbind from. Can be a keyboard, mouse, joystick or a gamepad.\n"
    "@param action The device action to unbind from. The action is dependant upon the device. Specify a key for keyboards.\n"
    "@return True if the unbind was successful, false if the device was unknown or description failed.\n\n"
-	"@tsexample\n"
-	"moveMap.unbind(\"keyboard\", \"space\");\n"
-	"@endtsexample\n\n")
+   "@tsexample\n"
+   "moveMap.unbind(\"keyboard\", \"space\");\n"
+   "@endtsexample\n\n")
 {
    return object->processUnbind( device, action );
 }
@@ -1977,7 +1977,7 @@ DefineEngineMethod( ActionMap, unbindObj, bool, ( const char* device, const char
    "@param action The device action to unbind from. The action is dependant upon the device. Specify a key for keyboards.\n"
    "@param obj The object to perform unbind against.\n"
    "@return True if the unbind was successful, false if the device was unknown or description failed.\n"
-	"@tsexample\n"
+   "@tsexample\n"
    "moveMap.unbindObj(\"keyboard\", \"numpad1\", \"rangeChange\", %player);"
    "@endtsexample\n\n\n")
 {
@@ -1991,15 +1991,15 @@ DefineEngineMethod( ActionMap, unbindObj, bool, ( const char* device, const char
     return object->processUnbind( device, action, simObject );
 }
 
-DefineEngineMethod( ActionMap, save, void, ( const char* fileName, bool append ), ( NULL, false ),
+DefineEngineMethod( ActionMap, save, void, ( const char* fileName, bool append ), ( nullAsType<const char*>(), false ),
    "@brief Saves the ActionMap to a file or dumps it to the console.\n\n"
    "@param fileName The file path to save the ActionMap to. If a filename is not specified "
    " the ActionMap will be dumped to the console.\n"
    "@param append Whether to write the ActionMap at the end of the file or overwrite it.\n"
-	"@tsexample\n"
-	"// Write out the actionmap into the config.cs file\n"
+   "@tsexample\n"
+   "// Write out the actionmap into the config.cs file\n"
    "moveMap.save( \"scripts/client/config.cs\" );"
-	"@endtsexample\n\n")
+   "@endtsexample\n\n")
 {
    char buffer[1024];
 
@@ -2015,7 +2015,7 @@ DefineEngineMethod( ActionMap, save, void, ( const char* fileName, bool append )
 DefineEngineFunction( getCurrentActionMap, ActionMap*, (),,
    "@brief Returns the current %ActionMap.\n"
    "@see ActionMap"
-	"@ingroup Input")
+   "@ingroup Input")
 {
    SimSet* pActionMapSet = Sim::getActiveActionMapSet();
    return dynamic_cast< ActionMap* >( pActionMapSet->last() );
@@ -2024,10 +2024,10 @@ DefineEngineFunction( getCurrentActionMap, ActionMap*, (),,
 DefineEngineMethod( ActionMap, push, void, (),,
    "@brief Push the ActionMap onto the %ActionMap stack.\n\n"
    "Activates an ActionMap and placees it at the top of the ActionMap stack.\n\n"
-	"@tsexample\n"
-	"// Make moveMap the active action map\n"
-	"moveMap.push();\n"
-	"@endtsexample\n\n"
+   "@tsexample\n"
+   "// Make moveMap the active action map\n"
+   "moveMap.push();\n"
+   "@endtsexample\n\n"
    "@see ActionMap")
 {
    SimSet* pActionMapSet = Sim::getActiveActionMapSet();
@@ -2037,10 +2037,10 @@ DefineEngineMethod( ActionMap, push, void, (),,
 DefineEngineMethod( ActionMap, pop, void, (),,
    "@brief Pop the ActionMap off the %ActionMap stack.\n\n"
    "Deactivates an %ActionMap and removes it from the @ActionMap stack.\n"
-	"@tsexample\n"
-	"// Deactivate moveMap\n"
-	"moveMap.pop();\n"
-	"@endtsexample\n\n"
+   "@tsexample\n"
+   "// Deactivate moveMap\n"
+   "moveMap.pop();\n"
+   "@endtsexample\n\n"
    "@see ActionMap")
 {
    SimSet* pActionMapSet = Sim::getActiveActionMapSet();
@@ -2053,20 +2053,20 @@ DefineEngineMethod( ActionMap, getBinding, const char*, ( const char* command ),
    "@param command The function to search bindings for.\n"
    "@return The binding against the specified command. Returns an empty string(\"\") "
    "if a binding wasn't found.\n"
-	"@tsexample\n"
-	"// Find what the function \"jump()\" is bound to in moveMap\n"
-	"%bind = moveMap.getBinding( \"jump\" );\n\n"
-	"if ( %bind !$= \"\" )\n"
-	"{\n"
-	"// Find out what device is used in the binding\n"
-	"	%device = getField( %bind, 0 );\n\n"
-	"// Find out what action (such as a key) is used in the binding\n"
-	"	%action = getField( %bind, 1 );\n"
-	"}\n"
-	"@endtsexample\n\n"
+   "@tsexample\n"
+   "// Find what the function \"jump()\" is bound to in moveMap\n"
+   "%bind = moveMap.getBinding( \"jump\" );\n\n"
+   "if ( %bind !$= \"\" )\n"
+   "{\n"
+   "// Find out what device is used in the binding\n"
+   "  %device = getField( %bind, 0 );\n\n"
+   "// Find out what action (such as a key) is used in the binding\n"
+   "  %action = getField( %bind, 1 );\n"
+   "}\n"
+   "@endtsexample\n\n"
    "@see getField")
 {
-	return object->getBinding( command );	
+   return object->getBinding( command );  
 }
 
 DefineEngineMethod( ActionMap, getCommand, const char*, ( const char* device, const char* action ),,
@@ -2074,15 +2074,15 @@ DefineEngineMethod( ActionMap, getCommand, const char*, ( const char* device, co
    "@param device The device that was bound. Can be a keyboard, mouse, joystick or a gamepad.\n"
    "@param action The device action that was bound.  The action is dependant upon the device. Specify a key for keyboards.\n"
    "@return The command against the specified device and action.\n"
-	"@tsexample\n"
-	"// Find what function is bound to a device\'s action\n"
-	"// In this example, \"jump()\" was assigned to the space key in another script\n"
-	"%command = moveMap.getCommand(\"keyboard\", \"space\");\n\n"
-	"// Should print \"jump\" in the console\n"
-	"echo(%command)\n"
-	"@endtsexample\n\n")
+   "@tsexample\n"
+   "// Find what function is bound to a device\'s action\n"
+   "// In this example, \"jump()\" was assigned to the space key in another script\n"
+   "%command = moveMap.getCommand(\"keyboard\", \"space\");\n\n"
+   "// Should print \"jump\" in the console\n"
+   "echo(%command)\n"
+   "@endtsexample\n\n")
 {
-	return object->getCommand( device, action );	
+   return object->getCommand( device, action ); 
 }
 
 DefineEngineMethod( ActionMap, isInverted, bool, ( const char* device, const char* action ),,
@@ -2091,12 +2091,12 @@ DefineEngineMethod( ActionMap, isInverted, bool, ( const char* device, const cha
    "@param device The device that was bound. Can be a keyboard, mouse, joystick or a gamepad.\n"
    "@param action The device action that was bound.  The action is dependant upon the device. Specify a key for keyboards.\n"
    "@return True if the specified device and action is inverted.\n"
-	"@tsexample\n"
+   "@tsexample\n"
    "%if ( moveMap.isInverted( \"mouse\", \"xaxis\"))\n"
    "   echo(\"Mouse's xAxis is inverted\");"
-	"@endtsexample\n\n")
+   "@endtsexample\n\n")
 {
-	return object->isInverted( device, action );	
+   return object->isInverted( device, action ); 
 }
 
 DefineEngineMethod( ActionMap, getScale, F32, ( const char* device, const char* action ),,
@@ -2104,11 +2104,11 @@ DefineEngineMethod( ActionMap, getScale, F32, ( const char* device, const char*
    "@param device The device that was bound. Can be keyboard, mouse, joystick or gamepad.\n"
    "@param action The device action that was bound. The action is dependant upon the device. Specify a key for keyboards.\n"
    "@return Any scaling applied to the specified device and action.\n"
-	"@tsexample\n"
-	"%scale = %moveMap.getScale( \"gamepad\", \"thumbrx\");\n"
-	"@endtsexample\n\n")
+   "@tsexample\n"
+   "%scale = %moveMap.getScale( \"gamepad\", \"thumbrx\");\n"
+   "@endtsexample\n\n")
 {
-	return object->getScale( device, action );	
+   return object->getScale( device, action );   
 }
 
 DefineEngineMethod( ActionMap, getDeadZone, const char*, ( const char* device, const char* action ),,
@@ -2117,11 +2117,11 @@ DefineEngineMethod( ActionMap, getDeadZone, const char*, ( const char* device, c
    "@param action The device action that was bound. The action is dependant upon the device. Specify a key for keyboards.\n"
    "@return The dead zone for the specified device and action. Returns \"0 0\" if there is no dead zone " 
    "or an empty string(\"\") if the mapping was not found.\n"
-	"@tsexample\n"
-	"%deadZone = moveMap.getDeadZone( \"gamepad\", \"thumbrx\");\n"
-	"@endtsexample\n\n")
+   "@tsexample\n"
+   "%deadZone = moveMap.getDeadZone( \"gamepad\", \"thumbrx\");\n"
+   "@endtsexample\n\n")
 {
-	return object->getDeadZone( device, action );	
+   return object->getDeadZone( device, action );   
 }
 
 //------------------------------------------------------------------------------

Engine/source/ts/tsShapeConstruct.h

@@ -97,7 +97,8 @@ public:
       {
          eCommandType      type;       // Command type
          StringTableEntry  name;       // Command name
-         String            argv[10];   // Command arguments
+         static const U32 MAX_ARGS = 10;
+         String            argv[MAX_ARGS];   // Command arguments
          S32               argc;       // Number of arguments
          Command() : type(CmdInvalid), name(0), argc(0) { }
          Command( const char* _name )
@@ -105,68 +106,12 @@ public:
          {
             name = StringTable->insert( _name );
          }
-
-         // Helper functions to fill in the command arguments
-         inline void addArgs() { }
-
-         template< typename A >
-            inline void addArgs( A a )
-         {
-            argv[argc++] = EngineMarshallData( a );
-         }
-         template< typename A, typename B > void addArgs( A a, B b )
-         {
-            addArgs( a );
-            addArgs( b );
-         } 
-         template< typename A, typename B, typename C >
-            inline void addArgs( A a, B b, C c )
-         {
-            addArgs( a );
-            addArgs( b, c );
-         }
-         template< typename A, typename B, typename C, typename D >
-            inline void addArgs( A a, B b, C c, D d )
-         {
-            addArgs( a );
-            addArgs( b, c, d );
-         }
-         template< typename A, typename B, typename C, typename D, typename E >
-            inline void addArgs( A a, B b, C c, D d, E e )
-         {
-            addArgs( a );
-            addArgs( b, c, d, e );
-         }
-         template< typename A, typename B, typename C, typename D, typename E, typename F >
-            inline void addArgs( A a, B b, C c, D d, E e, F f )
-         {
-            addArgs( a );
-            addArgs( b, c, d, e, f );
-         }
-         template< typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-            inline void addArgs( A a, B b, C c, D d, E e, F f, G g )
-         {
-            addArgs( a );
-            addArgs( b, c, d, e, f, g );
-         }
-         template< typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-            inline void addArgs( A a, B b, C c, D d, E e, F f, G g, H h )
-         {
-            addArgs( a );
-            addArgs( b, c, d, e, f, g, h );
-         }
-         template< typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
-            inline void addArgs( A a, B b, C c, D d, E e, F f, G g, H h, I i )
-         {
-            addArgs( a );
-            addArgs( b, c, d, e, f, g, h, i );
-         }
-         template< typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J >
-            inline void addArgs( A a, B b, C c, D d, E e, F f, G g, H h, I i, J j )
-         {
-            addArgs( a );
-            addArgs( b, c, d, e, f, g, h, i, j );
-         }
+        
+        // Helper functions to fill in the command arguments
+        template<typename ...ArgTs> inline void addArgs(ArgTs ...args){
+           using Helper = engineAPI::detail::MarshallHelpers<String>;
+           Helper::marshallEach(argc, argv, args...);
+        }
       };
 
       Vector<Command>   mCommands;