TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-02-12 19:31:41 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'master' into console-func-refactor

Browse source 
Conflicts:
	Engine/source/app/net/net.cpp
	Engine/source/console/astNodes.cpp
	Engine/source/console/compiledEval.cpp
	Engine/source/console/console.h
	Engine/source/console/consoleInternal.h
	Engine/source/console/engineAPI.h
This commit is contained in:
Daniel Buckmaster 2014-10-14 14:40:17 +11:00
commit b507dc9555
6487 changed files with 315149 additions and 609761 deletions
Download patch file Download diff file Expand all files Collapse all files

132
Engine/source/console/engineAPI.h
View file

@ -76,6 +76,7 @@
// Disable some VC warnings that are irrelevant to us.
#pragma warning( push )
#pragma warning( disable : 4510 ) // default constructor could not be generated; all the Args structures are never constructed by us
#pragma warning( disable : 4610 ) // can never be instantiated; again Args is never constructed by us
@ -557,7 +558,7 @@ struct _EngineTrampoline< R( A, B, C, D, E, F, G ) >
}
typename EngineTypeTraits< G >::ValueType g() const
{
return EngineTypeTraits< F >::ArgumentToValue(
return EngineTypeTraits< G >::ArgumentToValue(
*( reinterpret_cast< const typename EngineTypeTraits< G >::ArgumentValueType* >
( &data[ sizeof( typename EngineTypeTraits< A >::ArgumentValueType ) +
sizeof( typename EngineTypeTraits< B >::ArgumentValueType ) +
@ -1072,7 +1073,7 @@ struct _EngineFunctionTrampoline< R( A, B, C, D, E, F, G, H ) > : public _Engine
{
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 ) );
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 >
@ -1398,14 +1399,14 @@ struct _EngineConsoleThunkCountArgs
// Encapsulation of a legacy console function invocation.
template< int startArgc, typename T >
template< S32 startArgc, typename T >
struct _EngineConsoleThunk {};
template< int startArgc, typename R >
template< S32 startArgc, typename R >
struct _EngineConsoleThunk< startArgc, R() >
{
typedef typename _EngineConsoleThunkType< R >::ReturnType ReturnType;
static const int NUM_ARGS = 0;
static const S32 NUM_ARGS = 0;
static ReturnType thunk( S32 argc, ConsoleValueRef *argv, R ( *fn )(), const _EngineFunctionDefaultArguments< void() >& )
{
return _EngineConsoleThunkReturnValue( fn() );
@ -1416,11 +1417,11 @@ struct _EngineConsoleThunk< startArgc, R() >
return _EngineConsoleThunkReturnValue( ( frame->*fn )() );
}
};
template< int startArgc >
template< S32 startArgc >
struct _EngineConsoleThunk< startArgc, void() >
{
typedef void ReturnType;
static const int NUM_ARGS = 0;
static const S32 NUM_ARGS = 0;
static void thunk( S32 argc, ConsoleValueRef *argv, void ( *fn )(), const _EngineFunctionDefaultArguments< void() >& )
{
fn();
@ -1432,11 +1433,11 @@ struct _EngineConsoleThunk< startArgc, void() >
}
};
template< int startArgc, typename R, typename A >
template< S32 startArgc, typename R, typename A >
struct _EngineConsoleThunk< startArgc, R( A ) >
{
typedef typename _EngineConsoleThunkType< R >::ReturnType ReturnType;
static const int NUM_ARGS = 1 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1449,11 +1450,11 @@ struct _EngineConsoleThunk< startArgc, R( A ) >
return _EngineConsoleThunkReturnValue( ( frame->*fn )( a ) );
}
};
template< int startArgc, typename A >
template< S32 startArgc, typename A >
struct _EngineConsoleThunk< startArgc, void( A ) >
{
typedef void ReturnType;
static const int NUM_ARGS = 1 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1467,11 +1468,11 @@ struct _EngineConsoleThunk< startArgc, void( A ) >
}
};
template< int startArgc, typename R, typename A, typename B >
template< S32 startArgc, typename R, typename A, typename B >
struct _EngineConsoleThunk< startArgc, R( A, B ) >
{
typedef typename _EngineConsoleThunkType< R >::ReturnType ReturnType;
static const int NUM_ARGS = 2 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1486,11 +1487,11 @@ struct _EngineConsoleThunk< startArgc, R( A, B ) >
return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b ) );
}
};
template< int startArgc, typename A, typename B >
template< S32 startArgc, typename A, typename B >
struct _EngineConsoleThunk< startArgc, void( A, B ) >
{
typedef void ReturnType;
static const int NUM_ARGS = 2 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1506,11 +1507,11 @@ struct _EngineConsoleThunk< startArgc, void( A, B ) >
}
};
template< int startArgc, typename R, typename A, typename B, typename C >
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 int NUM_ARGS = 3 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1527,11 +1528,11 @@ struct _EngineConsoleThunk< startArgc, R( A, B, C ) >
return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c ) );
}
};
template< int startArgc, typename A, typename B, typename C >
template< S32 startArgc, typename A, typename B, typename C >
struct _EngineConsoleThunk< startArgc, void( A, B, C ) >
{
typedef void ReturnType;
static const int NUM_ARGS = 3 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1549,11 +1550,11 @@ struct _EngineConsoleThunk< startArgc, void( A, B, C ) >
}
};
template< int startArgc, typename R, typename A, typename B, typename C, typename D >
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 int NUM_ARGS = 4 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1572,11 +1573,11 @@ struct _EngineConsoleThunk< startArgc, R( A, B, C, D ) >
return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c, d ) );
}
};
template< int startArgc, typename A, typename B, typename C, typename 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 int NUM_ARGS = 4 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1596,11 +1597,11 @@ struct _EngineConsoleThunk< startArgc, void( A, B, C, D ) >
}
};
template< int startArgc, typename R, typename A, typename B, typename C, typename D, typename E >
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 int NUM_ARGS = 5 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1621,11 +1622,11 @@ struct _EngineConsoleThunk< startArgc, R( A, B, C, D, E ) >
return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c, d, e ) );
}
};
template< int startArgc, typename A, typename B, typename C, typename D, typename 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 int NUM_ARGS = 5 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1647,11 +1648,11 @@ struct _EngineConsoleThunk< startArgc, void( A, B, C, D, E ) >
}
};
template< int startArgc, typename R, typename A, typename B, typename C, typename D, typename E, typename F >
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 int NUM_ARGS = 6 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1674,11 +1675,11 @@ struct _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F ) >
return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c, d, e, f ) );
}
};
template< int startArgc, typename A, typename B, typename C, typename D, typename E, typename 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 int NUM_ARGS = 6 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1702,11 +1703,11 @@ struct _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F ) >
}
};
template< int startArgc, typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G >
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 int NUM_ARGS = 7 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1731,11 +1732,11 @@ struct _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F, G ) >
return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c, d, e, f, g ) );
}
};
template< int startArgc, typename A, typename B, typename C, typename D, typename E, typename F, typename 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 int NUM_ARGS = 7 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1761,11 +1762,11 @@ struct _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F, G ) >
}
};
template< int startArgc, typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
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 int NUM_ARGS = 8 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1792,11 +1793,11 @@ struct _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F, G, H ) >
return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c, d, e, f, g, h ) );
}
};
template< int startArgc, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename 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 int NUM_ARGS = 8 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1824,11 +1825,11 @@ struct _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F, G, H ) >
}
};
template< int startArgc, typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I >
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 int NUM_ARGS = 9 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1857,11 +1858,11 @@ struct _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F, G, H, I ) >
return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c, d, e, f, g, h, i ) );
}
};
template< int startArgc, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename 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 int NUM_ARGS = 9 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1891,11 +1892,11 @@ struct _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F, G, H, I ) >
}
};
template< int startArgc, typename R, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename 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 >
struct _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F, G, H, I, J ) >
{
typedef typename _EngineConsoleThunkType< R >::ReturnType ReturnType;
static const int NUM_ARGS = 10 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1926,11 +1927,11 @@ struct _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F, G, H, I, J ) >
return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c, d, e, f, g, h, i, j ) );
}
};
template< int startArgc, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename 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 int NUM_ARGS = 10 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1961,11 +1962,11 @@ struct _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F, G, H, I, J ) >
( frame->*fn )( a, b, c, d, e, f, g, h, i, j );
}
};
template< int 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 >
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 int NUM_ARGS = 11 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -1998,11 +1999,11 @@ struct _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F, G, H, I, J, K ) >
return _EngineConsoleThunkReturnValue( ( frame->*fn )( a, b, c, d, e, f, g, h, i, j, k ) );
}
};
template< int startArgc, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename 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 int NUM_ARGS = 11 + startArgc;
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 < argc ? EngineUnmarshallData< A >()( argv[ startArgc ] ) : A( defaultArgs.a ) );
@ -2547,79 +2548,79 @@ struct _EngineCallbackHelper
R call() const
{
typedef R( FunctionType )( EngineObject* );
return R( reinterpret_cast< FunctionType* >( mFn )( mThis ) );
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* >( mFn )( mThis, 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* >( mFn )( mThis, 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* >( mFn )( mThis, 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* >( mFn )( mThis, 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* >( mFn )( mThis, 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* >( mFn )( mThis, 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* >( mFn )( mThis, 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* >( mFn )( mThis, 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* >( mFn )( mThis, 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* >( mFn )( mThis, 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* >( mFn )( mThis, 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 l );
return R( reinterpret_cast< FunctionType* >( mFn )( mThis, 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 ) );
}
};
@ -2808,7 +2809,6 @@ struct _EngineConsoleCallbackHelper
// Re-enable some VC warnings we disabled for this file.
#pragma warning( default : 4510 )
#pragma warning( default : 4610 )
#pragma warning( pop ) // 4510 and 4610
#endif // !_ENGINEAPI_H_