TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-07-15 16:44:36 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

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
commit 0c6174b045
21 changed files with 977 additions and 5439 deletions
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; 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" "@brief Check whether an object is in line of sight.\n"
"@obj Object to check. (If blank, it will check the current target).\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" "@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)); 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" "@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" "@obj Object to check. (If blank, it will check the current target).\n"
"@fov view angle in degrees.(Defaults to 45)\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(); 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" "@brief The distance to a given object.\n"
"@obj Object to check. (If blank, it will check the current target).\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") "@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" "Assigns the datablock for this emitter node.\n"
"@param emitterDatablock ParticleEmitterData datablock to assign\n" "@param emitterDatablock ParticleEmitterData datablock to assign\n"
"@tsexample\n" "@tsexample\n"

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

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

4
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 // 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 // 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" "@brief Change one of the materials on the shape.\n\n"
"This method changes materials per mapTo with others. The material that " "This method changes materials per mapTo with others. The material that "
@ -1323,4 +1323,4 @@ DefineEngineMethod( TSStatic, getModelFile, const char *, (),,
) )
{ {
return object->getShapeFileName(); return object->getShapeFileName();
} }

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

@ -254,7 +254,7 @@ DefineEngineFunction(addBadWord, bool, (const char* badWord),,
return gBadWordFilter->addBadWord(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" "@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" "Uses the bad word filter to determine which characters within the string will be replaced.\n\n"

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

@ -95,8 +95,8 @@ struct ConsoleLogEntry
Script, Script,
GUI, GUI,
Network, Network,
GGConnect, GGConnect,
NUM_TYPE NUM_TYPE
} mType; } mType;
/// Indicates the actual log entry. /// Indicates the actual log entry.
@ -897,34 +897,28 @@ template<typename P1> struct _EngineConsoleExecCallbackHelper;
namespace Con namespace Con
{ {
/// @name Console Execution - executef /// @name Console Execution - executef
/// { /// {
/// ///
/// Implements a script function thunk which automatically converts parameters to relevant console types. /// Implements a script function thunk which automatically converts parameters to relevant console types.
/// Can be used as follows: /// Can be used as follows:
/// - Con::executef("functionName", ...); /// - Con::executef("functionName", ...);
/// - Con::executef(mySimObject, "functionName", ...); /// - Con::executef(mySimObject, "functionName", ...);
/// ///
/// NOTE: if you get a rather cryptic template error coming through here, most likely you are trying to /// 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. /// 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" /// Another problem can occur if you do not include "console/simBase.h" and "console/engineAPI.h"
/// since _EngineConsoleExecCallbackHelper and SimConsoleThreadExecCallback are required. /// since _EngineConsoleExecCallbackHelper and SimConsoleThreadExecCallback are required.
/// ///
/// @see _EngineConsoleExecCallbackHelper /// @see _EngineConsoleExecCallbackHelper
/// ///
template<typename A> ConsoleValueRef executef(A a) { _EngineConsoleExecCallbackHelper<A> callback( a ); return callback.template call<ConsoleValueRef>(); } template<typename R, typename ...ArgTs>
template<typename A, typename B> ConsoleValueRef executef(A a, B b) { _EngineConsoleExecCallbackHelper<A> callback( a ); return callback.template call<ConsoleValueRef>(b); } ConsoleValueRef executef(R r, ArgTs ...argTs)
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); } _EngineConsoleExecCallbackHelper<R> callback( r );
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); } return callback.template call<ConsoleValueRef>(argTs...);
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); }
/// }
}; };
extern void expandEscape(char *dest, const char *src); extern void expandEscape(char *dest, const char *src);
@ -1149,19 +1143,19 @@ class ConsoleStackFrameSaver
{ {
public: public:
bool mSaved; bool mSaved;
ConsoleStackFrameSaver() : mSaved(false) ConsoleStackFrameSaver() : mSaved(false)
{ {
} }
~ConsoleStackFrameSaver() ~ConsoleStackFrameSaver()
{ {
restore(); restore();
} }
void save(); void save();
void restore(); void restore();
}; };

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

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

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

File diff suppressed because it is too large Load diff

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

@ -23,6 +23,8 @@
#ifndef _ENGINEFUNCTIONS_H_ #ifndef _ENGINEFUNCTIONS_H_
#define _ENGINEFUNCTIONS_H_ #define _ENGINEFUNCTIONS_H_
#include <tuple>
#ifndef _ENGINEEXPORTS_H_ #ifndef _ENGINEEXPORTS_H_
#include "console/engineExports.h" #include "console/engineExports.h"
#endif #endif
@ -87,693 +89,38 @@ struct EngineFunctionDefaultArguments
// Structure encapsulating default arguments to an engine API function. // Structure encapsulating default arguments to an engine API function.
template< typename T > template< typename T >
struct _EngineFunctionDefaultArguments {}; 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
{
typename EngineTypeTraits< A >::DefaultArgumentValueStoreType a;
typename EngineTypeTraits< B >::DefaultArgumentValueStoreType b;
typename EngineTypeTraits< C >::DefaultArgumentValueStoreType c;
typename EngineTypeTraits< D >::DefaultArgumentValueStoreType d;
_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;
_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;
_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;
_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() template<typename ...ArgTs>
{ mNumDefaultArgs = 0; } struct _EngineFunctionDefaultArguments< void(ArgTs...) > : public EngineFunctionDefaultArguments
_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; template<typename T> using DefVST = typename EngineTypeTraits<T>::DefaultArgumentValueStoreType;
typename EngineTypeTraits< B >::DefaultArgumentValueStoreType b; std::tuple<DefVST<ArgTs> ...> mArgs;
typename EngineTypeTraits< C >::DefaultArgumentValueStoreType c; private:
typename EngineTypeTraits< D >::DefaultArgumentValueStoreType d; using SelfType = _EngineFunctionDefaultArguments< void(ArgTs...) >;
typename EngineTypeTraits< E >::DefaultArgumentValueStoreType e;
typename EngineTypeTraits< F >::DefaultArgumentValueStoreType f; template<size_t ...> struct Seq {};
typename EngineTypeTraits< G >::DefaultArgumentValueStoreType g; template<size_t N, size_t ...S> struct Gens : Gens<N-1, N-1, S...> {};
typename EngineTypeTraits< H >::DefaultArgumentValueStoreType h;
typename EngineTypeTraits< I >::DefaultArgumentValueStoreType i; template<size_t ...I> struct Gens<0, I...>{ typedef Seq<I...> type; };
typename EngineTypeTraits< J >::DefaultArgumentValueStoreType j;
typename EngineTypeTraits< K >::DefaultArgumentValueStoreType k; template<typename ...TailTs, size_t ...I>
typename EngineTypeTraits< L >::DefaultArgumentValueStoreType l; 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( L l ) template<typename ...TailTs> using MaybeSelfEnabled = typename std::enable_if<sizeof...(TailTs) <= sizeof...(ArgTs), decltype(mArgs)>::type;
: l( l )
{ mNumDefaultArgs = 1; } template<typename ...TailTs> static MaybeSelfEnabled<TailTs...> tailInit(TailTs ...tail) {
_EngineFunctionDefaultArguments( K k, L l ) std::tuple<DefVST<ArgTs>...> argsT;
: k( k ), std::tuple<DefVST<TailTs>...> tailT = std::make_tuple(tail...);
l( l ) SelfType::copyHelper<TailTs...>(argsT, tailT, typename Gens<sizeof...(TailTs)>::type());
{ mNumDefaultArgs = 2; } return argsT;
_EngineFunctionDefaultArguments( J j, K k, L l ) };
: j( j ),
k( k ), public:
l( l ) template<typename ...TailTs> _EngineFunctionDefaultArguments(TailTs ...tail)
{ mNumDefaultArgs = 3; } : EngineFunctionDefaultArguments({sizeof...(TailTs)}), mArgs(SelfType::tailInit(tail...))
_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; }
}; };
#pragma pack( pop ) #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(U32);
DECLARE_PRIMITIVE_R(F32); DECLARE_PRIMITIVE_R(F32);
DECLARE_PRIMITIVE_R(F64); DECLARE_PRIMITIVE_R(F64);
DECLARE_PRIMITIVE_R(U64);
DECLARE_PRIMITIVE_R(S64);
DECLARE_PRIMITIVE_R(void*); 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. // Function Argument Type Infos.
//-------------------------------------------------------------------------- //--------------------------------------------------------------------------
template< typename R >
struct _EngineArgumentTypeTable< R() > : public EngineArgumentTypeTable #ifdef TORQUE_COMILER_GCC
{ #define ARGS_SIZE_SAFE(wanted) (wanted)
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 #else
static const EngineTypeInfo* const ARGS[ 1 ]; #define ARGS_SIZE_SAFE(wanted) (((wanted) < 1) ? 1 : (wanted))
#endif #endif
_EngineArgumentTypeTable() template< typename R, typename ...ArgTs >
: EngineArgumentTypeTable( TYPE< typename EngineTypeTraits< R >::Type >(), NUM_ARGUMENTS, ARGS ) {} struct _EngineArgumentTypeTable< R( ArgTs ... ) > : public EngineArgumentTypeTable
};
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() >
{ {
static const bool VARIADIC = true; static const U32 NUM_ARGUMENTS = sizeof...(ArgTs);
_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 bool VARIADIC = false;
static const EngineTypeInfo* const RETURN; static const EngineTypeInfo* const RETURN;
static const EngineTypeInfo* const ARGS[ 1 ]; static const EngineTypeInfo* const ARGS[ ARGS_SIZE_SAFE(sizeof...(ArgTs)) ];
_EngineArgumentTypeTable() _EngineArgumentTypeTable()
: EngineArgumentTypeTable( TYPE< typename EngineTypeTraits< R >::Type >(), NUM_ARGUMENTS, ARGS ) {} : EngineArgumentTypeTable( TYPE< typename EngineTypeTraits< R >::Type >(), NUM_ARGUMENTS, ARGS ) {}
}; };
template< typename R, typename A > template< typename R, typename ...ArgTs >
const EngineTypeInfo* const _EngineArgumentTypeTable< R( A ) >::RETURN = TYPE< typename EngineTypeTraits< R >::Type >(); const EngineTypeInfo* const _EngineArgumentTypeTable< R( ArgTs ... ) >::RETURN = TYPE< typename EngineTypeTraits< R >::Type >();
template< typename R, typename A > template< typename R, typename ...ArgTs >
const EngineTypeInfo* const _EngineArgumentTypeTable< R( A ) >::ARGS[ 1 ] = 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 > template< typename R, typename ... ArgTs >
struct _EngineArgumentTypeTable< R( A, ... ) > : public _EngineArgumentTypeTable< R( A ) > struct _EngineArgumentTypeTable< R( ArgTs ..., ... ) > : public _EngineArgumentTypeTable< R( ArgTs ... ) >
{
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 ) >
{ {
static const bool VARIADIC = true; static const bool VARIADIC = true;
_EngineArgumentTypeTable() {} _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. // are not guaranteed to be any meaningful value or base types to the engine type system.
#define T( x ) typename EngineTypeTraits< x >::ValueType #define T( x ) typename EngineTypeTraits< x >::ValueType
template< typename R > template<typename R, typename ...ArgTs>
struct _EngineTypeTraits< R() > : public _EngineFunctionTypeTraits< T( R )() > {}; struct _EngineTypeTraits< R(ArgTs ...) > : public _EngineFunctionTypeTraits<T(R)(T(ArgTs)...)> {};
template< typename R > template<typename R, typename ...ArgTs>
struct _EngineTypeTraits< R( ... ) > : public _EngineFunctionTypeTraits< T( R )( ... ) > {}; struct _EngineTypeTraits< R(ArgTs ..., ...) > : public _EngineFunctionTypeTraits<T(R)(T(ArgTs)..., ...)> {};
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 ), ... ) > {};
#undef T #undef T

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

@ -178,7 +178,7 @@ void GFXShader::_unlinkBuffer( GFXShaderConstBuffer *buf )
DefineEngineFunction( addGlobalShaderMacro, void, 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 " "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 " "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 " "macro of the same name. For the new macro to take effect all the shaders "

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

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

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

@ -52,42 +52,42 @@
IMPLEMENT_CONOBJECT(GuiCanvas); IMPLEMENT_CONOBJECT(GuiCanvas);
ConsoleDocClass( 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" "@subsection GuiCanvas_content_contentcontrol Content Control\n"
"A content control is the top level GuiControl for a screen. This GuiControl " "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 " "will be the parent control for all other GuiControls on that particular "
"screen.\n\n" "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 " "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 " "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 " "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 " "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 " "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 " "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 " "layer is on top and will get all the input, unless the dialog is "
"modeless, which is a profile option.\n\n" "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. " "The GuiCanvas is based on dirty regions. "
"Every frame the canvas paints only the areas of the canvas that are 'dirty' " "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. " "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. " "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 " "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 " "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" "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 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 we're recording, store the intial video resolution
if (Journal::IsRecording()) if (Journal::IsRecording())
{ {
Journal::Write(vm.resolution.x); Journal::Write(vm.resolution.x);
Journal::Write(vm.resolution.y); Journal::Write(vm.resolution.y);
Journal::Write(vm.fullScreen); Journal::Write(vm.fullScreen);
} }
//If we're playing, read the intial video resolution from the journal //If we're playing, read the intial video resolution from the journal
if (Journal::IsPlaying()) if (Journal::IsPlaying())
{ {
Journal::Read(&vm.resolution.x); Journal::Read(&vm.resolution.x);
Journal::Read(&vm.resolution.y); Journal::Read(&vm.resolution.y);
Journal::Read(&vm.fullScreen); Journal::Read(&vm.fullScreen);
} }
if (a && a->mType != NullDevice) if (a && a->mType != NullDevice)
{ {
mPlatformWindow = WindowManager->createWindow(newDevice, vm); mPlatformWindow = WindowManager->createWindow(newDevice, vm);
//Disable window resizing if recording ir playing a journal //Disable window resizing if recording ir playing a journal
if (Journal::IsRecording() || Journal::IsPlaying()) if (Journal::IsRecording() || Journal::IsPlaying())
mPlatformWindow->lockSize(true); mPlatformWindow->lockSize(true);
// Set a minimum on the window size so people can't break us by resizing tiny. // Set a minimum on the window size so people can't break us by resizing tiny.
mPlatformWindow->setMinimumWindowSize(Point2I(640,480)); mPlatformWindow->setMinimumWindowSize(Point2I(640,480));
// Now, we have to hook in our event callbacks so we'll get // Now, we have to hook in our event callbacks so we'll get
// appropriate events from the window. // appropriate events from the window.
@ -326,12 +326,12 @@ CanvasSizeChangeSignal GuiCanvas::smCanvasSizeChangeSignal;
void GuiCanvas::handleResize( WindowId did, S32 width, S32 height ) void GuiCanvas::handleResize( WindowId did, S32 width, S32 height )
{ {
getCanvasSizeChangeSignal().trigger(this); getCanvasSizeChangeSignal().trigger(this);
if (Journal::IsPlaying() && mPlatformWindow) if (Journal::IsPlaying() && mPlatformWindow)
{ {
mPlatformWindow->lockSize(false); mPlatformWindow->lockSize(false);
mPlatformWindow->setSize(Point2I(width, height)); mPlatformWindow->setSize(Point2I(width, height));
mPlatformWindow->lockSize(true); mPlatformWindow->lockSize(true);
} }
// Notify the scripts // Notify the scripts
if ( isMethod( "onResize" ) ) if ( isMethod( "onResize" ) )
@ -342,9 +342,9 @@ void GuiCanvas::handlePaintEvent(WindowId did)
{ {
bool canRender = mPlatformWindow->isVisible() && GFX->allowRender() && !GFX->canCurrentlyRender(); bool canRender = mPlatformWindow->isVisible() && GFX->allowRender() && !GFX->canCurrentlyRender();
// Do the screenshot first. // Do the screenshot first.
if ( gScreenShot != NULL && gScreenShot->isPending() && canRender ) 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 the video capture is waiting for a canvas, start the capture
if ( VIDCAP->isWaitingForCanvas() && canRender ) if ( VIDCAP->isWaitingForCanvas() && canRender )
@ -560,19 +560,19 @@ bool GuiCanvas::tabNext(void)
//save the old //save the old
GuiControl *oldResponder = mFirstResponder; GuiControl *oldResponder = mFirstResponder;
GuiControl* newResponder = ctrl->findNextTabable(mFirstResponder); GuiControl* newResponder = ctrl->findNextTabable(mFirstResponder);
if ( !newResponder ) if ( !newResponder )
newResponder = ctrl->findFirstTabable(); newResponder = ctrl->findFirstTabable();
if ( newResponder && newResponder != oldResponder ) if ( newResponder && newResponder != oldResponder )
{ {
newResponder->setFirstResponder(); newResponder->setFirstResponder();
// CodeReview Can this get killed? Note tabPrev code. BJG - 3/25/07 // CodeReview Can this get killed? Note tabPrev code. BJG - 3/25/07
// if ( oldResponder ) // if ( oldResponder )
// oldResponder->onLoseFirstResponder(); // oldResponder->onLoseFirstResponder();
return true; return true;
} }
} }
return false; return false;
} }
@ -585,30 +585,30 @@ bool GuiCanvas::tabPrev(void)
//save the old //save the old
GuiControl *oldResponder = mFirstResponder; GuiControl *oldResponder = mFirstResponder;
GuiControl* newResponder = ctrl->findPrevTabable(mFirstResponder); GuiControl* newResponder = ctrl->findPrevTabable(mFirstResponder);
if ( !newResponder ) if ( !newResponder )
newResponder = ctrl->findLastTabable(); newResponder = ctrl->findLastTabable();
if ( newResponder && newResponder != oldResponder ) if ( newResponder && newResponder != oldResponder )
{ {
newResponder->setFirstResponder(); newResponder->setFirstResponder();
// CodeReview As with tabNext() above, looks like this can now go. DAW - 7/05/09 // CodeReview As with tabNext() above, looks like this can now go. DAW - 7/05/09
//if ( oldResponder ) //if ( oldResponder )
// oldResponder->onLoseFirstResponder(); // oldResponder->onLoseFirstResponder();
return true; return true;
} }
} }
return false; return false;
} }
bool GuiCanvas::processInputEvent(InputEventInfo &inputEvent) bool GuiCanvas::processInputEvent(InputEventInfo &inputEvent)
{ {
// First call the general input handler (on the extremely off-chance that it will be handled): // First call the general input handler (on the extremely off-chance that it will be handled):
if (mFirstResponder && mFirstResponder->onInputEvent(inputEvent)) if (mFirstResponder && mFirstResponder->onInputEvent(inputEvent))
{ {
return(true); return(true);
} }
switch (inputEvent.deviceType) 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)); addUpdateRegion(pos - Point2I(2, 2), Point2I(cext.x + 4, cext.y + 4));
} }
mLastCursorEnabled = cursorVisible; mLastCursorEnabled = cursorVisible;
mLastCursor = mouseCursor; mLastCursor = mouseCursor;
mLastCursorPt = cursorPos; mLastCursorPt = cursorPos;
// Begin GFX // Begin GFX
PROFILE_START(GFXBeginScene); PROFILE_START(GFXBeginScene);
@ -1830,7 +1830,7 @@ void GuiCanvas::renderFrame(bool preRenderOnly, bool bufferSwap /* = true */)
resetUpdateRegions(); resetUpdateRegions();
// Make sure we have a clean matrix state // Make sure we have a clean matrix state
// before we start rendering anything! // before we start rendering anything!
GFX->setWorldMatrix( MatrixF::Identity ); GFX->setWorldMatrix( MatrixF::Identity );
GFX->setViewMatrix( MatrixF::Identity ); GFX->setViewMatrix( MatrixF::Identity );
@ -2039,46 +2039,46 @@ void GuiCanvas::resetUpdateRegions()
void GuiCanvas::setFirstResponder( GuiControl* newResponder ) void GuiCanvas::setFirstResponder( GuiControl* newResponder )
{ {
GuiControl* oldResponder = mFirstResponder; GuiControl* oldResponder = mFirstResponder;
Parent::setFirstResponder( newResponder ); Parent::setFirstResponder( newResponder );
if( oldResponder == mFirstResponder ) if( oldResponder == mFirstResponder )
return; return;
if( oldResponder && ( oldResponder != newResponder ) ) if( oldResponder && ( oldResponder != newResponder ) )
oldResponder->onLoseFirstResponder(); oldResponder->onLoseFirstResponder();
if( newResponder && ( newResponder != oldResponder ) ) if( newResponder && ( newResponder != oldResponder ) )
newResponder->onGainFirstResponder(); newResponder->onGainFirstResponder();
} }
DefineEngineMethod( GuiCanvas, getContent, S32, (),, 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" "@tsexample\n"
"Canvas.getContent();\n" "Canvas.getContent();\n"
"@endtsexample\n\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) if(ctrl)
return ctrl->getId(); return ctrl->getId();
return -1; return -1;
} }
DefineEngineMethod( GuiCanvas, setContent, void, (GuiControl* ctrl),, 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" "@tsexample\n"
"Canvas.setContent(PlayGui);\n" "Canvas.setContent(PlayGui);\n"
"@endtsexample\n\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(argv[2][0])
// { // {
// if (!Sim::findObject(argv[2], gui)) // if (!Sim::findObject(argv[2], gui))
@ -2088,11 +2088,11 @@ DefineEngineMethod( GuiCanvas, setContent, void, (GuiControl* ctrl),,
// } // }
// } // }
if(!ctrl) if(!ctrl)
{ {
Con::errorf("GuiCanvas::setContent - Invalid control specified')"); Con::errorf("GuiCanvas::setContent - Invalid control specified')");
return; return;
} }
//set the new content control //set the new content control
object->setContentControl(ctrl); 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)" 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; GuiControl *gui;
if (! Sim::findObject(ctrlName, gui)) if (! Sim::findObject(ctrlName, gui))
{ {
Con::printf("pushDialog(): Invalid control: %s", ctrlName); Con::printf("pushDialog(): Invalid control: %s", ctrlName);
return; return;
@ -2147,8 +2147,8 @@ ConsoleDocFragment _popDialog2(
"void popDialog();" "void popDialog();"
); );
DefineConsoleMethod( GuiCanvas, popDialog, void, (GuiControl * gui), (NULL), "(GuiControl ctrl=NULL)" DefineConsoleMethod( GuiCanvas, popDialog, void, (GuiControl * gui), (nullAsType<GuiControl*>()), "(GuiControl ctrl=NULL)"
"@hide") "@hide")
{ {
if (gui) if (gui)
object->popDialogControl(gui); object->popDialogControl(gui);
@ -2157,160 +2157,160 @@ DefineConsoleMethod( GuiCanvas, popDialog, void, (GuiControl * gui), (NULL), "(G
} }
ConsoleDocFragment _popLayer1( ConsoleDocFragment _popLayer1(
"@brief Removes the top most layer of dialogs\n\n" "@brief Removes the top most layer of dialogs\n\n"
"@tsexample\n" "@tsexample\n"
"Canvas.popLayer();\n" "Canvas.popLayer();\n"
"@endtsexample\n\n", "@endtsexample\n\n",
"GuiCanvas", "GuiCanvas",
"void popLayer();" "void popLayer();"
); );
ConsoleDocFragment _popLayer2( ConsoleDocFragment _popLayer2(
"@brief Removes a specified layer of dialogs\n\n" "@brief Removes a specified layer of dialogs\n\n"
"@param layer Number of the layer to pop\n\n" "@param layer Number of the layer to pop\n\n"
"@tsexample\n" "@tsexample\n"
"Canvas.popLayer(1);\n" "Canvas.popLayer(1);\n"
"@endtsexample\n\n", "@endtsexample\n\n",
"GuiCanvas", "GuiCanvas",
"void popLayer(S32 layer);" "void popLayer(S32 layer);"
); );
DefineConsoleMethod( GuiCanvas, popLayer, void, (S32 layer), (0), "(int layer)" DefineConsoleMethod( GuiCanvas, popLayer, void, (S32 layer), (0), "(int layer)"
"@hide") "@hide")
{ {
object->popDialogControl(layer); object->popDialogControl(layer);
} }
DefineEngineMethod( GuiCanvas, cursorOn, void, (),, DefineEngineMethod( GuiCanvas, cursorOn, void, (),,
"@brief Turns on the mouse cursor.\n\n" "@brief Turns on the mouse cursor.\n\n"
"@tsexample\n" "@tsexample\n"
"Canvas.cursorOn();\n" "Canvas.cursorOn();\n"
"@endtsexample\n\n") "@endtsexample\n\n")
{ {
object->setCursorON(true); object->setCursorON(true);
} }
DefineEngineMethod( GuiCanvas, cursorOff, void, (),, DefineEngineMethod( GuiCanvas, cursorOff, void, (),,
"@brief Turns on the mouse off.\n\n" "@brief Turns on the mouse off.\n\n"
"@tsexample\n" "@tsexample\n"
"Canvas.cursorOff();\n" "Canvas.cursorOff();\n"
"@endtsexample\n\n") "@endtsexample\n\n")
{ {
object->setCursorON(false); object->setCursorON(false);
} }
DefineEngineMethod( GuiCanvas, setCursor, void, (GuiCursor* cursor),, 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" "@tsexample\n"
"Canvas.setCursor(\"DefaultCursor\");\n" "Canvas.setCursor(\"DefaultCursor\");\n"
"@endtsexample\n\n") "@endtsexample\n\n")
{ {
if(!cursor) if(!cursor)
{ {
Con::errorf("GuiCanvas::setCursor - Invalid GuiCursor name or ID"); Con::errorf("GuiCanvas::setCursor - Invalid GuiCursor name or ID");
return; return;
} }
object->setCursor(cursor); object->setCursor(cursor);
} }
DefineEngineMethod( GuiCanvas, renderFront, void, ( bool enable ),, 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" "@tsexample\n"
"Canvas.renderFront(false);\n" "Canvas.renderFront(false);\n"
"@endtsexample\n\n") "@endtsexample\n\n")
{ {
object->setRenderFront(enable); object->setRenderFront(enable);
} }
DefineEngineMethod( GuiCanvas, showCursor, void, (),, DefineEngineMethod( GuiCanvas, showCursor, void, (),,
"@brief Enable rendering of the cursor.\n\n" "@brief Enable rendering of the cursor.\n\n"
"@tsexample\n" "@tsexample\n"
"Canvas.showCursor();\n" "Canvas.showCursor();\n"
"@endtsexample\n\n") "@endtsexample\n\n")
{ {
object->showCursor(true); object->showCursor(true);
} }
DefineEngineMethod( GuiCanvas, hideCursor, void, (),, DefineEngineMethod( GuiCanvas, hideCursor, void, (),,
"@brief Disable rendering of the cursor.\n\n" "@brief Disable rendering of the cursor.\n\n"
"@tsexample\n" "@tsexample\n"
"Canvas.hideCursor();\n" "Canvas.hideCursor();\n"
"@endtsexample\n\n") "@endtsexample\n\n")
{ {
object->showCursor(false); object->showCursor(false);
} }
DefineEngineMethod( GuiCanvas, isCursorOn, bool, (),, DefineEngineMethod( GuiCanvas, isCursorOn, bool, (),,
"@brief Determines if mouse cursor is enabled.\n\n" "@brief Determines if mouse cursor is enabled.\n\n"
"@tsexample\n" "@tsexample\n"
"// Is cursor on?\n" "// Is cursor on?\n"
"if(Canvas.isCursorOn())\n" "if(Canvas.isCursorOn())\n"
" echo(\"Canvas cursor is on\");\n" " echo(\"Canvas cursor is on\");\n"
"@endtsexample\n\n" "@endtsexample\n\n"
"@return Returns true if the cursor is on.\n\n") "@return Returns true if the cursor is on.\n\n")
{ {
return object->isCursorON(); return object->isCursorON();
} }
DefineEngineMethod( GuiCanvas, isCursorShown, bool, (),, DefineEngineMethod( GuiCanvas, isCursorShown, bool, (),,
"@brief Determines if mouse cursor is rendering.\n\n" "@brief Determines if mouse cursor is rendering.\n\n"
"@tsexample\n" "@tsexample\n"
"// Is cursor rendering?\n" "// Is cursor rendering?\n"
"if(Canvas.isCursorShown())\n" "if(Canvas.isCursorShown())\n"
" echo(\"Canvas cursor is rendering\");\n" " echo(\"Canvas cursor is rendering\");\n"
"@endtsexample\n\n" "@endtsexample\n\n"
"@return Returns true if the cursor is rendering.\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), 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 " "If the elapsed time is greater than the time since the last paint "
"then the repaint will be skipped.\n" "then the repaint will be skipped.\n"
"@param elapsedMS The optional elapsed time in milliseconds.\n\n" "@param elapsedMS The optional elapsed time in milliseconds.\n\n"
"@tsexample\n" "@tsexample\n"
"Canvas.repaint();\n" "Canvas.repaint();\n"
"@endtsexample\n\n") "@endtsexample\n\n")
{ {
object->repaint(elapsedMS < 0 ? 0 : elapsedMS); object->repaint(elapsedMS < 0 ? 0 : elapsedMS);
} }
DefineEngineMethod( GuiCanvas, reset, void, (),, 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" "@tsexample\n"
"Canvas.reset();\n" "Canvas.reset();\n"
"@endtsexample\n\n") "@endtsexample\n\n")
{ {
object->resetUpdateRegions(); object->resetUpdateRegions();
} }
DefineEngineMethod( GuiCanvas, getCursorPos, Point2I, (),, 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," " might be outside the Torque window. If you want to get the position within the Canvas,"
" call screenToClient on the result.\n\n" " call screenToClient on the result.\n\n"
"@see Canvas::screenToClient()\n\n" "@see Canvas::screenToClient()\n\n"
"@param param Description\n\n" "@param param Description\n\n"
"@tsexample\n" "@tsexample\n"
"%cursorPos = Canvas.getCursorPos();\n" "%cursorPos = Canvas.getCursorPos();\n"
"@endtsexample\n\n" "@endtsexample\n\n"
"@return Screen coordinates of mouse cursor, in format \"X Y\"") "@return Screen coordinates of mouse cursor, in format \"X Y\"")
{ {
return object->getCursorPos(); return object->getCursorPos();
} }
ConsoleDocFragment _setCursorPos1( ConsoleDocFragment _setCursorPos1(
@ -2334,21 +2334,21 @@ ConsoleDocFragment _setCursorPos2(
); );
DefineConsoleMethod( GuiCanvas, setCursorPos, void, (Point2I pos), , "(Point2I pos)" DefineConsoleMethod( GuiCanvas, setCursorPos, void, (Point2I pos), , "(Point2I pos)"
"@hide") "@hide")
{ {
object->setCursorPos(pos); object->setCursorPos(pos);
} }
DefineEngineMethod( GuiCanvas, getMouseControl, S32, (),, DefineEngineMethod( GuiCanvas, getMouseControl, S32, (),,
"@brief Gets the gui control under the mouse.\n\n" "@brief Gets the gui control under the mouse.\n\n"
"@tsexample\n" "@tsexample\n"
"%underMouse = Canvas.getMouseControl();\n" "%underMouse = Canvas.getMouseControl();\n"
"@endtsexample\n\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) if (control)
return control->getId(); return control->getId();
@ -2356,18 +2356,18 @@ DefineEngineMethod( GuiCanvas, getMouseControl, S32, (),,
} }
DefineEngineFunction(excludeOtherInstance, bool, (const char* appIdentifer),, 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 Platform\n"
"@ingroup GuiCore") "@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) #if !defined(TORQUE_OS_MAC) && !defined(TORQUE_OS_XENON) && !defined(TORQUE_DEBUG) && !defined(TORQUE_OS_LINUX)
return Platform::excludeOtherInstances(appIdentifer); return Platform::excludeOtherInstances(appIdentifer);
#else #else
@ -2377,82 +2377,82 @@ DefineEngineFunction(excludeOtherInstance, bool, (const char* appIdentifer),,
} }
DefineEngineMethod( GuiCanvas, getExtent, Point2I, (),, DefineEngineMethod( GuiCanvas, getExtent, Point2I, (),,
"@brief Returns the dimensions of the canvas\n\n" "@brief Returns the dimensions of the canvas\n\n"
"@tsexample\n" "@tsexample\n"
"%extent = Canvas.getExtent();\n" "%extent = Canvas.getExtent();\n"
"@endtsexample\n\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),, 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" "@tsexample\n"
"Canvas.setWindowTitle(\"Documentation Rocks!\");\n" "Canvas.setWindowTitle(\"Documentation Rocks!\");\n"
"@endtsexample\n\n") "@endtsexample\n\n")
{ {
object->setWindowTitle(newTitle); object->setWindowTitle(newTitle);
} }
DefineEngineMethod( GuiCanvas, findFirstMatchingMonitor, S32, (const char* name),, 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" "The actual match algorithm depends on the implementation.\n"
"@param name The name to search for.\n\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); return PlatformWindowManager::get()->findFirstMatchingMonitor(name);
} }
DefineEngineMethod( GuiCanvas, getMonitorCount, S32, (),, 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(); return PlatformWindowManager::get()->getMonitorCount();
} }
DefineEngineMethod( GuiCanvas, getMonitorName, const char*, (S32 index),, 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" "@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); return PlatformWindowManager::get()->getMonitorName(index);
} }
DefineEngineMethod( GuiCanvas, getMonitorRect, RectI, (S32 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" "@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); return PlatformWindowManager::get()->getMonitorRect(index);
} }
DefineEngineMethod( GuiCanvas, getVideoMode, const char*, (),, 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). " "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" "You will need to parse out each one for individual use.\n\n"
"@tsexample\n" "@tsexample\n"
"%screenWidth = getWord(Canvas.getVideoMode(), 0);\n" "%screenWidth = getWord(Canvas.getVideoMode(), 0);\n"
"%screenHeight = getWord(Canvas.getVideoMode(), 1);\n" "%screenHeight = getWord(Canvas.getVideoMode(), 1);\n"
"%isFullscreen = getWord(Canvas.getVideoMode(), 2);\n" "%isFullscreen = getWord(Canvas.getVideoMode(), 2);\n"
"%bitdepth = getWord(Canvas.getVideoMode(), 3);\n" "%bitdepth = getWord(Canvas.getVideoMode(), 3);\n"
"%refreshRate = getWord(Canvas.getVideoMode(), 4);\n" "%refreshRate = getWord(Canvas.getVideoMode(), 4);\n"
"@endtsexample\n\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()) if (!object->getPlatformWindow())
return ""; return "";
@ -2463,17 +2463,17 @@ DefineEngineMethod( GuiCanvas, getVideoMode, const char*, (),,
DefineEngineMethod( GuiCanvas, getModeCount, S32, (),, 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" "@tsexample\n"
"%modeCount = Canvas.getModeCount()\n" "%modeCount = Canvas.getModeCount()\n"
"@endtsexample\n\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; return 0;
// Grab the available mode list from the device. // Grab the available mode list from the device.
@ -2485,12 +2485,12 @@ DefineEngineMethod( GuiCanvas, getModeCount, S32, (),,
} }
DefineEngineMethod( GuiCanvas, getMode, const char*, (S32 modeId),, DefineEngineMethod( GuiCanvas, getMode, const char*, (S32 modeId),,
"@brief Gets information on the specified mode of this device.\n\n" "@brief Gets information on the specified mode of this device.\n\n"
"@param modeId Index of the mode to get data from.\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" "@return A video mode string given an adapter and mode index.\n\n"
"@see GuiCanvas::getVideoMode()") "@see GuiCanvas::getVideoMode()")
{ {
if (!object->getPlatformWindow()) if (!object->getPlatformWindow())
return 0; return 0;
// Grab the available mode list from the device. // Grab the available mode list from the device.
@ -2515,14 +2515,14 @@ DefineEngineMethod( GuiCanvas, getMode, const char*, (S32 modeId),,
DefineEngineMethod( GuiCanvas, toggleFullscreen, void, (),, 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" "@tsexample\n"
"// If we are in windowed mode, the following will put is in fullscreen\n" "// If we are in windowed mode, the following will put is in fullscreen\n"
"Canvas.toggleFullscreen();" "Canvas.toggleFullscreen();"
"@endtsexample\n\n") "@endtsexample\n\n")
{ {
if (Platform::getWebDeployment()) if (Platform::getWebDeployment())
return; return;
if (!object->getPlatformWindow()) 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 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 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 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()) if (!object->getPlatformWindow())
return; return;

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

@ -716,16 +716,16 @@ void GuiEditCtrl::onRender(Point2I offset, const RectI &updateRect)
ctOffset = getCurrentAddSet()->localToGlobalCoord(Point2I(0,0)); ctOffset = getCurrentAddSet()->localToGlobalCoord(Point2I(0,0));
RectI box(ctOffset.x, ctOffset.y, cext.x, cext.y); 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 ) ); drawer->drawRect( box, ColorI( 50, 101, 152, 128 ) );
box.inset( 1, 1 ); box.inset( 1, 1 );
drawer->drawRect( box, ColorI( 50, 101, 152, 128 ) ); drawer->drawRect( box, ColorI( 50, 101, 152, 128 ) );
box.inset( 1, 1 ); box.inset( 1, 1 );
drawer->drawRect( box, ColorI( 50, 101, 152, 128 ) ); 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 ) ); drawer->drawRect( box, ColorI( 50, 101, 152, 128 ) );
box.inset( 1, 1 );
drawer->drawRect( box, ColorI( 50, 101, 152, 128 ) );
} }
Vector<GuiControl *>::iterator i; Vector<GuiControl *>::iterator i;
bool multisel = mSelectedControls.size() > 1; 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." ) DefineConsoleMethod( GuiEditCtrl, setContentControl, void, (GuiControl *ctrl ), , "( GuiControl ctrl ) - Set the toplevel control to edit in the GUI editor." )
{ {
if (ctrl) if (ctrl)
object->setContentControl(ctrl); object->setContentControl(ctrl);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
DefineConsoleMethod( GuiEditCtrl, addNewCtrl, void, (GuiControl *ctrl), , "(GuiControl ctrl)") DefineConsoleMethod( GuiEditCtrl, addNewCtrl, void, (GuiControl *ctrl), , "(GuiControl ctrl)")
{ {
if (ctrl) if (ctrl)
object->addNewControl(ctrl); object->addNewControl(ctrl);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -2518,7 +2518,7 @@ DefineConsoleMethod( GuiEditCtrl, clearSelection, void, (), , "Clear selected co
DefineConsoleMethod( GuiEditCtrl, select, void, (GuiControl *ctrl), , "(GuiControl ctrl)") DefineConsoleMethod( GuiEditCtrl, select, void, (GuiControl *ctrl), , "(GuiControl ctrl)")
{ {
if (ctrl) if (ctrl)
object->setSelection(ctrl, false); object->setSelection(ctrl, false);
} }
@ -2526,7 +2526,7 @@ DefineConsoleMethod( GuiEditCtrl, select, void, (GuiControl *ctrl), , "(GuiContr
DefineConsoleMethod( GuiEditCtrl, setCurrentAddSet, void, (GuiControl *addSet), , "(GuiControl ctrl)") DefineConsoleMethod( GuiEditCtrl, setCurrentAddSet, void, (GuiControl *addSet), , "(GuiControl ctrl)")
{ {
if (addSet) if (addSet)
object->setCurrentAddSet(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 ); 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 ); object->loadSelection( filename );

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

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

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

@ -306,7 +306,7 @@ void LightManager::_update4LightConsts( const SceneData &sgData,
GFXShaderConstHandle *lightInvRadiusSqSC, GFXShaderConstHandle *lightInvRadiusSqSC,
GFXShaderConstHandle *lightSpotDirSC, GFXShaderConstHandle *lightSpotDirSC,
GFXShaderConstHandle *lightSpotAngleSC, GFXShaderConstHandle *lightSpotAngleSC,
GFXShaderConstHandle *lightSpotFalloffSC, GFXShaderConstHandle *lightSpotFalloffSC,
GFXShaderConstBuffer *shaderConsts ) GFXShaderConstBuffer *shaderConsts )
{ {
PROFILE_SCOPE( LightManager_Update4LightConsts ); PROFILE_SCOPE( LightManager_Update4LightConsts );
@ -317,7 +317,7 @@ void LightManager::_update4LightConsts( const SceneData &sgData,
lightInvRadiusSqSC->isValid() || lightInvRadiusSqSC->isValid() ||
lightSpotDirSC->isValid() || lightSpotDirSC->isValid() ||
lightSpotAngleSC->isValid() || lightSpotAngleSC->isValid() ||
lightSpotFalloffSC->isValid() ) lightSpotFalloffSC->isValid() )
{ {
PROFILE_SCOPE( LightManager_Update4LightConsts_setLights ); PROFILE_SCOPE( LightManager_Update4LightConsts_setLights );
@ -326,7 +326,7 @@ void LightManager::_update4LightConsts( const SceneData &sgData,
static AlignedArray<Point4F> lightColors( 4, sizeof( Point4F ) ); static AlignedArray<Point4F> lightColors( 4, sizeof( Point4F ) );
static Point4F lightInvRadiusSq; static Point4F lightInvRadiusSq;
static Point4F lightSpotAngle; static Point4F lightSpotAngle;
static Point4F lightSpotFalloff; static Point4F lightSpotFalloff;
F32 range; F32 range;
// Need to clear the buffers so that we don't leak // 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; lightSpotDirs[2][i] = lightDir.z;
if ( light->getType() == LightInfo::Spot ) if ( light->getType() == LightInfo::Spot )
{ {
lightSpotAngle[i] = mCos( mDegToRad( light->getOuterConeAngle() / 2.0f ) ); 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 // Prescale the light color by the brightness to
// avoid doing this in the shader. // avoid doing this in the shader.
@ -379,7 +379,7 @@ void LightManager::_update4LightConsts( const SceneData &sgData,
shaderConsts->setSafe( lightSpotDirSC, lightSpotDirs ); shaderConsts->setSafe( lightSpotDirSC, lightSpotDirs );
shaderConsts->setSafe( lightSpotAngleSC, lightSpotAngle ); 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 ); 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" "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 " "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 " "lighting cache files can be written to. If mode is \"forceWritable\", then the lightmaps "

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

@ -892,7 +892,7 @@ bool SceneContainer::_castRay( U32 type, const Point3F& start, const Point3F& en
*info = ri; *info = ri;
info->point.interpolate(start, end, info->t); info->point.interpolate(start, end, info->t);
currentT = ri.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 = ri;
info->point.interpolate(start, end, info->t); info->point.interpolate(start, end, info->t);
currentT = ri.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 = ri;
info->point.interpolate(start, end, info->t); info->point.interpolate(start, end, info->t);
currentT = ri.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 //TODO: make RayInfo an API type
DefineEngineFunction( containerRayCast, const char*, 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" "@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 " "If pExempt is specified, then it is temporarily excluded from collision checks (For "

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

@ -36,138 +36,138 @@
IMPLEMENT_CONOBJECT(ActionMap); IMPLEMENT_CONOBJECT(ActionMap);
ConsoleDocClass( ActionMap, ConsoleDocClass( ActionMap,
"@brief ActionMaps assign platform input events to console commands.\n\n" "@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 " "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. " "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 " "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" "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" "@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 " "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" "three step process.\n\n"
"1. Check to see if the ActionMap exists\n" "1. Check to see if the ActionMap exists\n"
"2. Delete it if it exists\n" "2. Delete it if it exists\n"
"3. Instantiate the ActionMap\n\n" "3. Instantiate the ActionMap\n\n"
"The following is an example of how to create a new ActionMap:\n" "The following is an example of how to create a new ActionMap:\n"
"@tsexample\n" "@tsexample\n"
"if ( isObject( moveMap ) )\n" "if ( isObject( moveMap ) )\n"
" moveMap.delete();\n" " moveMap.delete();\n"
"new ActionMap(moveMap);" "new ActionMap(moveMap);"
"@endtsexample\n\n\n" "@endtsexample\n\n\n"
"@section ActionMap_binding Binding Functions\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" "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" "* Mouse\n\n"
"* Keyboard\n\n" "* Keyboard\n\n"
"* Joystick/Gamepad\n\n" "* Joystick/Gamepad\n\n"
"* Xbox 360 Controller\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, " "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(), " "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" "you specify a device, action to bind, then a function to be called when the event happens.\n\n"
"@tsexample\n" "@tsexample\n"
"// Simple function that prints to console\n" "// Simple function that prints to console\n"
"// %val - Sent by the device letting the user know\n" "// %val - Sent by the device letting the user know\n"
"// if an input was pressed (true) or released (false)\n" "// if an input was pressed (true) or released (false)\n"
"function testInput(%val)\n" "function testInput(%val)\n"
"{\n" "{\n"
" if(%val)\n" " if(%val)\n"
" echo(\"Key is down\");\n" " echo(\"Key is down\");\n"
" else\n" " else\n"
" echo(\"Key was released\");\n" " echo(\"Key was released\");\n"
"}\n\n" "}\n\n"
"// Bind the \'K\' key to the testInput function\n" "// Bind the \'K\' key to the testInput function\n"
"moveMap.bind(keyboard, \"k\", testInput);\n\n" "moveMap.bind(keyboard, \"k\", testInput);\n\n"
"@endtsexample\n\n\n" "@endtsexample\n\n\n"
"bindCmd is an alternative method for binding commands. This function is similar to bind(), " "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" "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" "When using bindCmd(), pass the functions as strings rather than the function names.\n\n"
"@tsexample\n" "@tsexample\n"
"// Print to the console when the spacebar is pressed\n" "// Print to the console when the spacebar is pressed\n"
"function onSpaceDown()\n" "function onSpaceDown()\n"
"{\n" "{\n"
" echo(\"Space bar down!\");\n" " echo(\"Space bar down!\");\n"
"}\n\n" "}\n\n"
"// Print to the console when the spacebar is released\n" "// Print to the console when the spacebar is released\n"
"function onSpaceUp()\n" "function onSpaceUp()\n"
"{\n" "{\n"
" echo(\"Space bar up!\");\n" " echo(\"Space bar up!\");\n"
"}\n\n" "}\n\n"
"// Bind the commands onSpaceDown and onSpaceUp to spacebar events\n" "// Bind the commands onSpaceDown and onSpaceUp to spacebar events\n"
"moveMap.bindCmd(keyboard, \"space\", \"onSpaceDown();\", \"onSpaceUp();\");\n" "moveMap.bindCmd(keyboard, \"space\", \"onSpaceDown();\", \"onSpaceUp();\");\n"
"@endtsexample\n\n" "@endtsexample\n\n"
"@section ActionMap_switching Switching ActionMaps\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 " "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" "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" "First, create two separate ActionMaps:\n\n"
"@tsexample\n" "@tsexample\n"
"// Create the two ActionMaps\n" "// Create the two ActionMaps\n"
"if ( isObject( moveMap ) )\n" "if ( isObject( moveMap ) )\n"
" moveMap.delete();\n" " moveMap.delete();\n"
"new ActionMap(moveMap);\n\n" "new ActionMap(moveMap);\n\n"
"if ( isObject( carMap ) )\n" "if ( isObject( carMap ) )\n"
" carMap.delete();\n" " carMap.delete();\n"
"new ActionMap(carMap);\n\n" "new ActionMap(carMap);\n\n"
"@endtsexample\n\n" "@endtsexample\n\n"
"Next, create the two separate functions. Both will be bound to spacebar, but not the same ActionMap:\n\n" "Next, create the two separate functions. Both will be bound to spacebar, but not the same ActionMap:\n\n"
"@tsexample\n" "@tsexample\n"
"// Print to the console the player is jumping\n" "// Print to the console the player is jumping\n"
"function playerJump(%val)\n" "function playerJump(%val)\n"
"{\n" "{\n"
" if(%val)\n" " if(%val)\n"
" echo(\"Player jumping!\");\n" " echo(\"Player jumping!\");\n"
"}\n\n" "}\n\n"
"// Print to the console the vehicle is charging\n" "// Print to the console the vehicle is charging\n"
"function turboCharge()\n" "function turboCharge()\n"
"{\n" "{\n"
" if(%val)\n" " if(%val)\n"
" echo(\"Vehicle turbo charging!\");\n" " echo(\"Vehicle turbo charging!\");\n"
"}\n" "}\n"
"@endtsexample\n\n" "@endtsexample\n\n"
"You are now ready to bind functions to your ActionMaps' devices:\n\n" "You are now ready to bind functions to your ActionMaps' devices:\n\n"
"@tsexample\n" "@tsexample\n"
"// Bind the spacebar to the playerJump function\n" "// Bind the spacebar to the playerJump function\n"
"// when moveMap is the active ActionMap\n" "// when moveMap is the active ActionMap\n"
"moveMap.bind(keyboard, \"space\", playerJump);\n\n" "moveMap.bind(keyboard, \"space\", playerJump);\n\n"
"// Bind the spacebar to the turboCharge function\n" "// Bind the spacebar to the turboCharge function\n"
"// when carMap is the active ActionMap\n" "// when carMap is the active ActionMap\n"
"carMap.bind(keyboard, \"space\", turboCharge);\n" "carMap.bind(keyboard, \"space\", turboCharge);\n"
"@endtsexample\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" "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" "@tsexample\n"
"// Make moveMap the active action map\n" "// Make moveMap the active action map\n"
"// You should now be able to activate playerJump with spacebar\n" "// You should now be able to activate playerJump with spacebar\n"
"moveMap.push();\n" "moveMap.push();\n"
"@endtsexample\n\n" "@endtsexample\n\n"
"To switch ActionMaps, first pop() the old one. Then you can push() the new one:\n\n" "To switch ActionMaps, first pop() the old one. Then you can push() the new one:\n\n"
"@tsexample\n" "@tsexample\n"
"// Deactivate moveMap\n" "// Deactivate moveMap\n"
"moveMap.pop();\n\n" "moveMap.pop();\n\n"
"// Activate carMap\n" "// Activate carMap\n"
"carMap.push();\n\n" "carMap.push();\n\n"
"@endtsexample\n\n\n" "@endtsexample\n\n\n"
"@ingroup Input" "@ingroup Input"
); );
// This is used for determing keys that have ascii codes for the foreign keyboards. IsAlpha doesn't work on foreign keys. // 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 ) const char* ActionMap::getCommand( const char* device, const char* action )
{ {
U32 deviceType; U32 deviceType;
U32 deviceInst; U32 deviceInst;
if ( getDeviceTypeAndInstance( device, deviceType, deviceInst ) ) if ( getDeviceTypeAndInstance( device, deviceType, deviceInst ) )
{ {
EventDescriptor eventDescriptor; EventDescriptor eventDescriptor;
if ( createEventDescriptor( action, &eventDescriptor ) ) if ( createEventDescriptor( action, &eventDescriptor ) )
{ {
const ActionMap::Node* mapNode = findNode( deviceType, deviceInst, eventDescriptor.flags, eventDescriptor.eventCode ); const ActionMap::Node* mapNode = findNode( deviceType, deviceInst, eventDescriptor.flags, eventDescriptor.eventCode );
if ( mapNode ) if ( mapNode )
{ {
if ( mapNode->flags & Node::BindCmd ) if ( mapNode->flags & Node::BindCmd )
{ {
S32 bufferLen = dStrlen( mapNode->makeConsoleCommand ) + dStrlen( mapNode->breakConsoleCommand ) + 2; S32 bufferLen = dStrlen( mapNode->makeConsoleCommand ) + dStrlen( mapNode->breakConsoleCommand ) + 2;
char* returnString = Con::getReturnBuffer( bufferLen ); char* returnString = Con::getReturnBuffer( bufferLen );
dSprintf( returnString, bufferLen, "%s\t%s", dSprintf( returnString, bufferLen, "%s\t%s",
( mapNode->makeConsoleCommand ? mapNode->makeConsoleCommand : "" ), ( mapNode->makeConsoleCommand ? mapNode->makeConsoleCommand : "" ),
( mapNode->breakConsoleCommand ? mapNode->breakConsoleCommand : "" ) ); ( mapNode->breakConsoleCommand ? mapNode->breakConsoleCommand : "" ) );
return( returnString ); return( returnString );
} }
else else
return( mapNode->consoleFunction ); return( mapNode->consoleFunction );
} }
} }
} }
return( "" ); return( "" );
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@ -808,92 +808,92 @@ const char* ActionMap::getCommand( const char* device, const char* action )
// Obviously, this should only be used for axes. // Obviously, this should only be used for axes.
bool ActionMap::isInverted( const char* device, const char* action ) bool ActionMap::isInverted( const char* device, const char* action )
{ {
U32 deviceType; U32 deviceType;
U32 deviceInst; U32 deviceInst;
if ( getDeviceTypeAndInstance( device, deviceType, deviceInst ) ) if ( getDeviceTypeAndInstance( device, deviceType, deviceInst ) )
{ {
EventDescriptor eventDescriptor; EventDescriptor eventDescriptor;
if ( createEventDescriptor( action, &eventDescriptor ) ) if ( createEventDescriptor( action, &eventDescriptor ) )
{ {
const ActionMap::Node* mapNode = findNode( deviceType, deviceInst, eventDescriptor.flags, eventDescriptor.eventCode ); const ActionMap::Node* mapNode = findNode( deviceType, deviceInst, eventDescriptor.flags, eventDescriptor.eventCode );
if ( mapNode ) if ( mapNode )
return( mapNode->flags & Node::Inverted ); return( mapNode->flags & Node::Inverted );
} }
} }
Con::errorf( "The input event specified by %s %s is not in this action map!", device, action ); Con::errorf( "The input event specified by %s %s is not in this action map!", device, action );
return( false ); return( false );
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
F32 ActionMap::getScale( const char* device, const char* action ) F32 ActionMap::getScale( const char* device, const char* action )
{ {
U32 deviceType; U32 deviceType;
U32 deviceInst; U32 deviceInst;
if ( getDeviceTypeAndInstance( device, deviceType, deviceInst ) ) if ( getDeviceTypeAndInstance( device, deviceType, deviceInst ) )
{ {
EventDescriptor eventDescriptor; EventDescriptor eventDescriptor;
if ( createEventDescriptor( action, &eventDescriptor ) ) if ( createEventDescriptor( action, &eventDescriptor ) )
{ {
const ActionMap::Node* mapNode = findNode( deviceType, deviceInst, eventDescriptor.flags, eventDescriptor.eventCode ); const ActionMap::Node* mapNode = findNode( deviceType, deviceInst, eventDescriptor.flags, eventDescriptor.eventCode );
if ( mapNode ) if ( mapNode )
{ {
if ( mapNode->flags & Node::HasScale ) if ( mapNode->flags & Node::HasScale )
return( mapNode->scaleFactor ); return( mapNode->scaleFactor );
else else
return( 1.0f ); return( 1.0f );
} }
} }
} }
Con::errorf( "The input event specified by %s %s is not in this action map!", device, action ); Con::errorf( "The input event specified by %s %s is not in this action map!", device, action );
return( 1.0f ); return( 1.0f );
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
const char* ActionMap::getDeadZone( const char* device, const char* action ) const char* ActionMap::getDeadZone( const char* device, const char* action )
{ {
U32 deviceType; U32 deviceType;
U32 deviceInst; U32 deviceInst;
if ( getDeviceTypeAndInstance( device, deviceType, deviceInst ) ) if ( getDeviceTypeAndInstance( device, deviceType, deviceInst ) )
{ {
EventDescriptor eventDescriptor; EventDescriptor eventDescriptor;
if ( createEventDescriptor( action, &eventDescriptor ) ) if ( createEventDescriptor( action, &eventDescriptor ) )
{ {
const ActionMap::Node* mapNode = findNode( deviceType, deviceInst, eventDescriptor.flags, eventDescriptor.eventCode ); const ActionMap::Node* mapNode = findNode( deviceType, deviceInst, eventDescriptor.flags, eventDescriptor.eventCode );
if ( mapNode ) if ( mapNode )
{ {
if ( mapNode->flags & Node::HasDeadZone ) if ( mapNode->flags & Node::HasDeadZone )
{ {
char buf[64]; char buf[64];
dSprintf( buf, sizeof( buf ), "%g %g", mapNode->deadZoneBegin, mapNode->deadZoneEnd ); dSprintf( buf, sizeof( buf ), "%g %g", mapNode->deadZoneBegin, mapNode->deadZoneEnd );
char* returnString = Con::getReturnBuffer( dStrlen( buf ) + 1 ); char* returnString = Con::getReturnBuffer( dStrlen( buf ) + 1 );
dStrcpy( returnString, buf ); dStrcpy( returnString, buf );
return( returnString ); return( returnString );
} }
else else
return( "0 0" ); return( "0 0" );
} }
} }
} }
Con::errorf( "The input event specified by %s %s is not in this action map!", device, action ); Con::errorf( "The input event specified by %s %s is not in this action map!", device, action );
return( "" ); return( "" );
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
const char* ActionMap::buildActionString( const InputEventInfo* event ) const char* ActionMap::buildActionString( const InputEventInfo* event )
{ {
const char* modifierString = getModifierString( event->modifier ); const char* modifierString = getModifierString( event->modifier );
char objectBuffer[64]; char objectBuffer[64];
if ( !getKeyString( event->objInst, objectBuffer ) ) if ( !getKeyString( event->objInst, objectBuffer ) )
return( "" ); return( "" );
U32 returnLen = dStrlen( modifierString ) + dStrlen( objectBuffer ) + 2; U32 returnLen = dStrlen( modifierString ) + dStrlen( objectBuffer ) + 2;
char* returnString = Con::getReturnBuffer( returnLen ); char* returnString = Con::getReturnBuffer( returnLen );
dSprintf( returnString, returnLen - 1, "%s%s", modifierString, objectBuffer ); dSprintf( returnString, returnLen - 1, "%s%s", modifierString, objectBuffer );
return( returnString ); return( returnString );
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@ -989,15 +989,15 @@ bool ActionMap::getDeviceName(const U32 deviceType, const U32 deviceInstance, ch
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
const char* ActionMap::getModifierString(const U32 modifiers) const char* ActionMap::getModifierString(const U32 modifiers)
{ {
U32 realModifiers = modifiers; U32 realModifiers = modifiers;
if ( modifiers & SI_LSHIFT || modifiers & SI_RSHIFT ) if ( modifiers & SI_LSHIFT || modifiers & SI_RSHIFT )
realModifiers |= SI_SHIFT; realModifiers |= SI_SHIFT;
if ( modifiers & SI_LCTRL || modifiers & SI_RCTRL ) if ( modifiers & SI_LCTRL || modifiers & SI_RCTRL )
realModifiers |= SI_CTRL; realModifiers |= SI_CTRL;
if ( modifiers & SI_LALT || modifiers & SI_RALT ) if ( modifiers & SI_LALT || modifiers & SI_RALT )
realModifiers |= SI_ALT; realModifiers |= SI_ALT;
if ( modifiers & SI_MAC_LOPT || modifiers & SI_MAC_ROPT ) if ( modifiers & SI_MAC_LOPT || modifiers & SI_MAC_ROPT )
realModifiers |= SI_MAC_OPT; realModifiers |= SI_MAC_OPT;
switch (realModifiers & (SI_SHIFT|SI_CTRL|SI_ALT|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" "@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" "@return True if the binding was successful, false if the device was unknown or description failed.\n\n"
"@tsexample\n" "@tsexample\n"
"// Simple function that prints to console\n" "// Simple function that prints to console\n"
"// %val - Sent by the device letting the user know\n" "// %val - Sent by the device letting the user know\n"
"// if an input was pressed (true) or released (false)\n" "// if an input was pressed (true) or released (false)\n"
"function testInput(%val)\n" "function testInput(%val)\n"
"{\n" "{\n"
" if(%val)\n" " if(%val)\n"
" echo(\"Key is down\");\n" " echo(\"Key is down\");\n"
" else\n" " else\n"
" echo(\"Key was released\");\n" " echo(\"Key was released\");\n"
"}\n\n" "}\n\n"
"// Bind the \'K\' key to the testInput function\n" "// Bind the \'K\' key to the testInput function\n"
"moveMap.bind(keyboard, k, testInput);\n\n" "moveMap.bind(keyboard, k, testInput);\n\n"
"@endtsexample\n\n\n", "@endtsexample\n\n\n",
"ActionMap", "ActionMap",
"bool bind( string device, string action, string command );"); "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" "@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" "@return True if the binding was successful, false if the device was unknown or description failed.\n\n"
"@tsexample\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" "mouse's movement along the X axis.\n"
"function testPitch(%val)\n" "function testPitch(%val)\n"
"{\n" "{\n"
" %pitchAdj = getMouseAdjustAmount(%val);\n" " %pitchAdj = getMouseAdjustAmount(%val);\n"
" $mvPitch += %pitchAdj;\n" " $mvPitch += %pitchAdj;\n"
"}\n\n" "}\n\n"
"// Bind the mouse's X axis to the testPitch function\n" "// Bind the mouse's X axis to the testPitch function\n"
"// DI is flagged, meaning input is inverted and has a deadzone\n" "// DI is flagged, meaning input is inverted and has a deadzone\n"
"%this.bind( mouse, \"xaxis\", \"DI\", \"-0.23 0.23\", testPitch );\n" "%this.bind( mouse, \"xaxis\", \"DI\", \"-0.23 0.23\", testPitch );\n"
"@endtsexample\n\n\n", "@endtsexample\n\n\n",
"ActionMap", "ActionMap",
"bool bind( string device, string action, string flag, string deadZone, string scale, string command );"); "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 )" ConsoleMethod( ActionMap, bind, bool, 5, 10, "actionMap.bind( device, action, [modifier spec, mod...], command )"
"@hide") "@hide")
{ {
StringStackWrapper args(argc - 2, argv + 2); StringStackWrapper args(argc - 2, argv + 2);
return object->processBind( args.count(), args, NULL ); 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 );"); "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)" ConsoleMethod( ActionMap, bindObj, bool, 6, 11, "(device, action, [modifier spec, mod...], command, object)"
"@hide") "@hide")
{ {
SimObject* simObject = Sim::findObject(argv[argc - 1]); SimObject* simObject = Sim::findObject(argv[argc - 1]);
if ( simObject == NULL ) 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 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" "@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" "@return True the bind was successful, false if the device was unknown or description failed.\n"
"@tsexample\n" "@tsexample\n"
"// Print to the console when the spacebar is pressed\n" "// Print to the console when the spacebar is pressed\n"
"function onSpaceDown()\n" "function onSpaceDown()\n"
"{\n" "{\n"
" echo(\"Space bar down!\");\n" " echo(\"Space bar down!\");\n"
"}\n\n" "}\n\n"
"// Print to the console when the spacebar is released\n" "// Print to the console when the spacebar is released\n"
"function onSpaceUp()\n" "function onSpaceUp()\n"
"{\n" "{\n"
" echo(\"Space bar up!\");\n" " echo(\"Space bar up!\");\n"
"}\n\n" "}\n\n"
"// Bind the commands onSpaceDown() and onSpaceUp() to spacebar events\n\n" "// Bind the commands onSpaceDown() and onSpaceUp() to spacebar events\n\n"
"moveMap.bindCmd(keyboard, \"space\", \"onSpaceDown();\", \"onSpaceUp();\");\n" "moveMap.bindCmd(keyboard, \"space\", \"onSpaceDown();\", \"onSpaceUp();\");\n"
"@endtsexample\n\n") "@endtsexample\n\n")
{ {
return object->processBindCmd( device, action, makeCmd, breakCmd ); 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 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" "@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" "@return True if the unbind was successful, false if the device was unknown or description failed.\n\n"
"@tsexample\n" "@tsexample\n"
"moveMap.unbind(\"keyboard\", \"space\");\n" "moveMap.unbind(\"keyboard\", \"space\");\n"
"@endtsexample\n\n") "@endtsexample\n\n")
{ {
return object->processUnbind( device, action ); 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 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" "@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" "@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);" "moveMap.unbindObj(\"keyboard\", \"numpad1\", \"rangeChange\", %player);"
"@endtsexample\n\n\n") "@endtsexample\n\n\n")
{ {
@ -1991,15 +1991,15 @@ DefineEngineMethod( ActionMap, unbindObj, bool, ( const char* device, const char
return object->processUnbind( device, action, simObject ); 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" "@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 " "@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" " 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" "@param append Whether to write the ActionMap at the end of the file or overwrite it.\n"
"@tsexample\n" "@tsexample\n"
"// Write out the actionmap into the config.cs file\n" "// Write out the actionmap into the config.cs file\n"
"moveMap.save( \"scripts/client/config.cs\" );" "moveMap.save( \"scripts/client/config.cs\" );"
"@endtsexample\n\n") "@endtsexample\n\n")
{ {
char buffer[1024]; char buffer[1024];
@ -2015,7 +2015,7 @@ DefineEngineMethod( ActionMap, save, void, ( const char* fileName, bool append )
DefineEngineFunction( getCurrentActionMap, ActionMap*, (),, DefineEngineFunction( getCurrentActionMap, ActionMap*, (),,
"@brief Returns the current %ActionMap.\n" "@brief Returns the current %ActionMap.\n"
"@see ActionMap" "@see ActionMap"
"@ingroup Input") "@ingroup Input")
{ {
SimSet* pActionMapSet = Sim::getActiveActionMapSet(); SimSet* pActionMapSet = Sim::getActiveActionMapSet();
return dynamic_cast< ActionMap* >( pActionMapSet->last() ); return dynamic_cast< ActionMap* >( pActionMapSet->last() );
@ -2024,10 +2024,10 @@ DefineEngineFunction( getCurrentActionMap, ActionMap*, (),,
DefineEngineMethod( ActionMap, push, void, (),, DefineEngineMethod( ActionMap, push, void, (),,
"@brief Push the ActionMap onto the %ActionMap stack.\n\n" "@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" "Activates an ActionMap and placees it at the top of the ActionMap stack.\n\n"
"@tsexample\n" "@tsexample\n"
"// Make moveMap the active action map\n" "// Make moveMap the active action map\n"
"moveMap.push();\n" "moveMap.push();\n"
"@endtsexample\n\n" "@endtsexample\n\n"
"@see ActionMap") "@see ActionMap")
{ {
SimSet* pActionMapSet = Sim::getActiveActionMapSet(); SimSet* pActionMapSet = Sim::getActiveActionMapSet();
@ -2037,10 +2037,10 @@ DefineEngineMethod( ActionMap, push, void, (),,
DefineEngineMethod( ActionMap, pop, void, (),, DefineEngineMethod( ActionMap, pop, void, (),,
"@brief Pop the ActionMap off the %ActionMap stack.\n\n" "@brief Pop the ActionMap off the %ActionMap stack.\n\n"
"Deactivates an %ActionMap and removes it from the @ActionMap stack.\n" "Deactivates an %ActionMap and removes it from the @ActionMap stack.\n"
"@tsexample\n" "@tsexample\n"
"// Deactivate moveMap\n" "// Deactivate moveMap\n"
"moveMap.pop();\n" "moveMap.pop();\n"
"@endtsexample\n\n" "@endtsexample\n\n"
"@see ActionMap") "@see ActionMap")
{ {
SimSet* pActionMapSet = Sim::getActiveActionMapSet(); 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" "@param command The function to search bindings for.\n"
"@return The binding against the specified command. Returns an empty string(\"\") " "@return The binding against the specified command. Returns an empty string(\"\") "
"if a binding wasn't found.\n" "if a binding wasn't found.\n"
"@tsexample\n" "@tsexample\n"
"// Find what the function \"jump()\" is bound to in moveMap\n" "// Find what the function \"jump()\" is bound to in moveMap\n"
"%bind = moveMap.getBinding( \"jump\" );\n\n" "%bind = moveMap.getBinding( \"jump\" );\n\n"
"if ( %bind !$= \"\" )\n" "if ( %bind !$= \"\" )\n"
"{\n" "{\n"
"// Find out what device is used in the binding\n" "// Find out what device is used in the binding\n"
" %device = getField( %bind, 0 );\n\n" " %device = getField( %bind, 0 );\n\n"
"// Find out what action (such as a key) is used in the binding\n" "// Find out what action (such as a key) is used in the binding\n"
" %action = getField( %bind, 1 );\n" " %action = getField( %bind, 1 );\n"
"}\n" "}\n"
"@endtsexample\n\n" "@endtsexample\n\n"
"@see getField") "@see getField")
{ {
return object->getBinding( command ); return object->getBinding( command );
} }
DefineEngineMethod( ActionMap, getCommand, const char*, ( const char* device, const char* action ),, 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 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" "@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" "@return The command against the specified device and action.\n"
"@tsexample\n" "@tsexample\n"
"// Find what function is bound to a device\'s action\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" "// In this example, \"jump()\" was assigned to the space key in another script\n"
"%command = moveMap.getCommand(\"keyboard\", \"space\");\n\n" "%command = moveMap.getCommand(\"keyboard\", \"space\");\n\n"
"// Should print \"jump\" in the console\n" "// Should print \"jump\" in the console\n"
"echo(%command)\n" "echo(%command)\n"
"@endtsexample\n\n") "@endtsexample\n\n")
{ {
return object->getCommand( device, action ); return object->getCommand( device, action );
} }
DefineEngineMethod( ActionMap, isInverted, bool, ( const char* device, const char* 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 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" "@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" "@return True if the specified device and action is inverted.\n"
"@tsexample\n" "@tsexample\n"
"%if ( moveMap.isInverted( \"mouse\", \"xaxis\"))\n" "%if ( moveMap.isInverted( \"mouse\", \"xaxis\"))\n"
" echo(\"Mouse's xAxis is inverted\");" " 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 ),, 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 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" "@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" "@return Any scaling applied to the specified device and action.\n"
"@tsexample\n" "@tsexample\n"
"%scale = %moveMap.getScale( \"gamepad\", \"thumbrx\");\n" "%scale = %moveMap.getScale( \"gamepad\", \"thumbrx\");\n"
"@endtsexample\n\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 ),, 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" "@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 " "@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" "or an empty string(\"\") if the mapping was not found.\n"
"@tsexample\n" "@tsexample\n"
"%deadZone = moveMap.getDeadZone( \"gamepad\", \"thumbrx\");\n" "%deadZone = moveMap.getDeadZone( \"gamepad\", \"thumbrx\");\n"
"@endtsexample\n\n") "@endtsexample\n\n")
{ {
return object->getDeadZone( device, action ); return object->getDeadZone( device, action );
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------

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

@ -97,7 +97,8 @@ public:
{ {
eCommandType type; // Command type eCommandType type; // Command type
StringTableEntry name; // Command name 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 S32 argc; // Number of arguments
Command() : type(CmdInvalid), name(0), argc(0) { } Command() : type(CmdInvalid), name(0), argc(0) { }
Command( const char* _name ) Command( const char* _name )
@ -105,68 +106,12 @@ public:
{ {
name = StringTable->insert( _name ); name = StringTable->insert( _name );
} }
// Helper functions to fill in the command arguments // Helper functions to fill in the command arguments
inline void addArgs() { } template<typename ...ArgTs> inline void addArgs(ArgTs ...args){
using Helper = engineAPI::detail::MarshallHelpers<String>;
template< typename A > Helper::marshallEach(argc, argv, args...);
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 );
}
}; };
Vector<Command> mCommands; Vector<Command> mCommands;