TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-01-19 20:24:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #1920 from elfprince13/variadicConsoleTemplates

Browse source 
Variadic console templates
This commit is contained in:
Areloch 2017-01-12 23:32:03 -06:00 committed by GitHub
parent 6164f36c47 d64e2a7019
commit 0c6174b045
21 changed files with 977 additions and 5439 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
Engine/source/T3D/aiPlayer.cpp
View file

@ -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")

2
Engine/source/T3D/fx/particleEmitterNode.cpp
View file

@ -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"

3
Engine/source/T3D/fx/ribbonNode.cpp
View file

@ -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"

2
Engine/source/T3D/tsStatic.cpp
View file

@ -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 "

2
Engine/source/app/badWordFilter.cpp
View file

@ -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"

18
Engine/source/console/console.h
View file

@ -912,18 +912,12 @@ namespace Con
///
/// @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); }
template<typename R, typename ...ArgTs>
ConsoleValueRef executef(R r, ArgTs ...argTs)
{
_EngineConsoleExecCallbackHelper<R> callback( r );
return callback.template call<ConsoleValueRef>(argTs...);
}
/// }
};

1
Engine/source/console/consoleTypes.h
View file

@ -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.

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

File diff suppressed because it is too large Load diff

705
Engine/source/console/engineFunctions.h
View file

@ -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
template<typename ...ArgTs>
struct _EngineFunctionDefaultArguments< void(ArgTs...) > : public EngineFunctionDefaultArguments
{
typename EngineTypeTraits< A >::DefaultArgumentValueStoreType a;
typename EngineTypeTraits< B >::DefaultArgumentValueStoreType b;
template<typename T> using DefVST = typename EngineTypeTraits<T>::DefaultArgumentValueStoreType;
std::tuple<DefVST<ArgTs> ...> mArgs;
private:
using SelfType = _EngineFunctionDefaultArguments< void(ArgTs...) >;
_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;
template<size_t ...> struct Seq {};
template<size_t N, size_t ...S> struct Gens : Gens<N-1, N-1, S...> {};
_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
{
typename EngineTypeTraits< A >::DefaultArgumentValueStoreType a;
typename EngineTypeTraits< B >::DefaultArgumentValueStoreType b;
typename EngineTypeTraits< C >::DefaultArgumentValueStoreType c;
typename EngineTypeTraits< D >::DefaultArgumentValueStoreType d;
template<size_t ...I> struct Gens<0, I...>{ typedef Seq<I...> type; };
_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<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( 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<typename ...TailTs> using MaybeSelfEnabled = typename std::enable_if<sizeof...(TailTs) <= sizeof...(ArgTs), decltype(mArgs)>::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;
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( 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;
_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;
_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;
_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 )

2
Engine/source/console/enginePrimitives.h
View file

@ -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*);

392
Engine/source/console/engineTypeInfo.h
View file

@ -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 ];
#ifdef TORQUE_COMILER_GCC
#define ARGS_SIZE_SAFE(wanted) (wanted)
#else
static const EngineTypeInfo* const ARGS[ 1 ];
#define ARGS_SIZE_SAFE(wanted) (((wanted) < 1) ? 1 : (wanted))
#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 ] = {};
#else
template< typename R > const EngineTypeInfo* const _EngineArgumentTypeTable< R() >::ARGS[ 1 ] = {};
#endif
template< typename R >
struct _EngineArgumentTypeTable< R( ... ) > : public _EngineArgumentTypeTable< R() >
template< typename R, typename ...ArgTs >
struct _EngineArgumentTypeTable< R( ArgTs ... ) > : public EngineArgumentTypeTable
{
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 U32 NUM_ARGUMENTS = sizeof...(ArgTs);
static const bool VARIADIC = false;
static const EngineTypeInfo* const RETURN;
static const EngineTypeInfo* const ARGS[ 1 ];
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 >
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 ] =
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< ArgTs >::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
{
static const U32 NUM_ARGUMENTS = 12;
static const bool VARIADIC = false;
static const EngineTypeInfo* const RETURN;
static const EngineTypeInfo* const ARGS[ 12 ];
_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 ] =
{
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 >()
};
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() {}

56
Engine/source/console/engineTypes.h
View file

@ -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

2
Engine/source/gfx/gfxShader.cpp
View file

@ -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 "

2
Engine/source/gfx/video/videoCapture.cpp
View file

@ -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" )
{

2
Engine/source/gui/core/guiCanvas.cpp
View file

@ -2147,7 +2147,7 @@ ConsoleDocFragment _popDialog2(
"void popDialog();"
);
DefineConsoleMethod( GuiCanvas, popDialog, void, (GuiControl * gui), (NULL), "(GuiControl ctrl=NULL)"
DefineConsoleMethod( GuiCanvas, popDialog, void, (GuiControl * gui), (nullAsType<GuiControl*>()), "(GuiControl ctrl=NULL)"
"@hide")
{
if (gui)

4
Engine/source/gui/editor/guiEditCtrl.cpp
View file

@ -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 );

2
Engine/source/gui/editor/guiMenuBar.cpp
View file

@ -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"

2
Engine/source/lighting/lightManager.cpp
View file

@ -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 "

2
Engine/source/scene/sceneContainer.cpp
View file

@ -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 "

2
Engine/source/sim/actionMap.cpp
View file

@ -1991,7 +1991,7 @@ 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"

65
Engine/source/ts/tsShapeConstruct.h
View file

@ -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 )
@ -107,65 +108,9 @@ public:
}
// 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 );
template<typename ...ArgTs> inline void addArgs(ArgTs ...args){
using Helper = engineAPI::detail::MarshallHelpers<String>;
Helper::marshallEach(argc, argv, args...);
}
};