Eliminate DefineConsoleFunction

Engine/source/T3D/aiClient.cpp

@@ -526,7 +526,7 @@ DefineConsoleMethod( AIClient, getLocation, Point3F, (),, "ai.getLocation();" )
 /**
  * Adds an AI Player to the game
  */
-DefineConsoleFunction( aiAddPlayer, S32, (const char * name, const char * ns), (""), "'playerName'[, 'AIClassType'] );")
+DefineEngineFunction( aiAddPlayer, S32, (const char * name, const char * ns), (""), "'playerName'[, 'AIClassType'] );")
 {
    // Create the player
    AIClient *aiPlayer = new AIClient();

Engine/source/T3D/entity.cpp

@@ -2005,7 +2005,7 @@ DefineConsoleMethod(Entity, notify, void, (String signalFunction, String argA, S
    object->notifyComponents(signalFunction, argA, argB, argC, argD, argE);
 }
 
-DefineConsoleFunction(findEntitiesByTag, const char*, (SimGroup* searchingGroup, String tags), (nullAsType<SimGroup*>(), ""),
+DefineEngineFunction(findEntitiesByTag, const char*, (SimGroup* searchingGroup, String tags), (nullAsType<SimGroup*>(), ""),
 "Finds all entities that have the provided tags.\n"
 "@param searchingGroup The SimGroup to search inside. If null, we'll search the entire dictionary(this can be slow!).\n"
 "@param tags Word delimited list of tags to search for. If multiple tags are included, the list is eclusively parsed, requiring all tags provided to be found on an entity for a match.\n"

Engine/source/T3D/gameBase/gameProcess.cpp

@@ -34,7 +34,7 @@ ClientProcessList* ClientProcessList::smClientProcessList = NULL;
 ServerProcessList* ServerProcessList::smServerProcessList = NULL;
 static U32 gNetOrderNextId = 0;
 
-DefineConsoleFunction( dumpProcessList, void, ( ), ,
+DefineEngineFunction( dumpProcessList, void, ( ), ,
    "Dumps all ProcessObjects in ServerProcessList and ClientProcessList to the console." )
 {
    Con::printf( "client process list:" );

Engine/source/T3D/gameFunctions.cpp

@@ -114,7 +114,7 @@ static U32 sgServerQueryIndex = 0;
 //SERVER FUNCTIONS ONLY
 ConsoleFunctionGroupBegin( Containers, "Spatial query functions. <b>Server side only!</b>");
 
-DefineConsoleFunction( containerFindFirst, const char*, (U32 typeMask, Point3F origin, Point3F size), , "(int mask, Point3F point, float x, float y, float z)"
+DefineEngineFunction( containerFindFirst, const char*, (U32 typeMask, Point3F origin, Point3F size), , "(int mask, Point3F point, float x, float y, float z)"
    "@brief Find objects matching the bitmask type within a box centered at point, with extents x, y, z.\n\n"
    "@returns The first object found, or an empty string if nothing was found.  Thereafter, you can get more "
    "results using containerFindNext()."
@@ -146,7 +146,7 @@ DefineConsoleFunction( containerFindFirst, const char*, (U32 typeMask, Point3F o
    return buff;
 }
 
-DefineConsoleFunction( containerFindNext, const char*, (), , "()"
+DefineEngineFunction( containerFindNext, const char*, (), , "()"
    "@brief Get more results from a previous call to containerFindFirst().\n\n"
    "@note You must call containerFindFirst() to begin the search.\n"
    "@returns The next object found, or an empty string if nothing else was found.\n"

Engine/source/T3D/physics/physicsPlugin.cpp

@@ -124,31 +124,31 @@ void PhysicsPlugin::_debugDraw( SceneManager *graph, const SceneRenderState *sta
       world->onDebugDraw( state );
 }
 
-DefineConsoleFunction( physicsPluginPresent, bool, (), , "physicsPluginPresent()"
+DefineEngineFunction( physicsPluginPresent, bool, (), , "physicsPluginPresent()"
    "@brief Returns true if a physics plugin exists and is initialized.\n\n"
    "@ingroup Physics" )
 {
    return PHYSICSMGR != NULL;
 }
 
-DefineConsoleFunction( physicsInit, bool, (const char * library), ("default"), "physicsInit( [string library] )")
+DefineEngineFunction( physicsInit, bool, (const char * library), ("default"), "physicsInit( [string library] )")
 {
    return PhysicsPlugin::activate( library );
 }
 
-DefineConsoleFunction( physicsDestroy, void, (), , "physicsDestroy()")
+DefineEngineFunction( physicsDestroy, void, (), , "physicsDestroy()")
 {
    if ( PHYSICSMGR )
       PHYSICSMGR->destroyPlugin();
 }
 
-DefineConsoleFunction( physicsInitWorld, bool, (const char * worldName), , "physicsInitWorld( String worldName )")
+DefineEngineFunction( physicsInitWorld, bool, (const char * worldName), , "physicsInitWorld( String worldName )")
 {
     bool res = PHYSICSMGR && PHYSICSMGR->createWorld( String( worldName ) );
    return res;
 }
 
-DefineConsoleFunction( physicsDestroyWorld, void, (const char * worldName), , "physicsDestroyWorld( String worldName )")
+DefineEngineFunction( physicsDestroyWorld, void, (const char * worldName), , "physicsDestroyWorld( String worldName )")
 {
    if ( PHYSICSMGR )
       PHYSICSMGR->destroyWorld( worldName );
@@ -157,19 +157,19 @@ DefineConsoleFunction( physicsDestroyWorld, void, (const char * worldName), , "p
 
 // Control/query of the stop/started state
 // of the currently running simulation.
-DefineConsoleFunction( physicsStartSimulation, void, (const char * worldName), , "physicsStartSimulation( String worldName )")
+DefineEngineFunction( physicsStartSimulation, void, (const char * worldName), , "physicsStartSimulation( String worldName )")
 {
    if ( PHYSICSMGR )
       PHYSICSMGR->enableSimulation( String( worldName ), true );
 }
 
-DefineConsoleFunction( physicsStopSimulation, void, (const char * worldName), , "physicsStopSimulation( String worldName )")
+DefineEngineFunction( physicsStopSimulation, void, (const char * worldName), , "physicsStopSimulation( String worldName )")
 {
    if ( PHYSICSMGR )
       PHYSICSMGR->enableSimulation( String( worldName ), false );
 }
 
-DefineConsoleFunction( physicsSimulationEnabled, bool, (), , "physicsStopSimulation( String worldName )")
+DefineEngineFunction( physicsSimulationEnabled, bool, (), , "physicsStopSimulation( String worldName )")
 {
    return PHYSICSMGR && PHYSICSMGR->isSimulationEnabled();
 }
@@ -177,14 +177,14 @@ DefineConsoleFunction( physicsSimulationEnabled, bool, (), , "physicsStopSimulat
 // Used for slowing down time on the
 // physics simulation, and for pausing/restarting
 // the simulation.
-DefineConsoleFunction( physicsSetTimeScale, void, (F32 scale), , "physicsSetTimeScale( F32 scale )")
+DefineEngineFunction( physicsSetTimeScale, void, (F32 scale), , "physicsSetTimeScale( F32 scale )")
 {
    if ( PHYSICSMGR )
       PHYSICSMGR->setTimeScale( scale );
 }
 
 // Get the currently set time scale.
-DefineConsoleFunction( physicsGetTimeScale, F32, (), , "physicsGetTimeScale()")
+DefineEngineFunction( physicsGetTimeScale, F32, (), , "physicsGetTimeScale()")
 {
    return PHYSICSMGR && PHYSICSMGR->getTimeScale();
 }
@@ -193,7 +193,7 @@ DefineConsoleFunction( physicsGetTimeScale, F32, (), , "physicsGetTimeScale()")
 // physics simulation that they should store
 // their current state for later restoration,
 // such as when the editor is closed.
-DefineConsoleFunction( physicsStoreState, void, (), , "physicsStoreState()")
+DefineEngineFunction( physicsStoreState, void, (), , "physicsStoreState()")
 {
    PhysicsPlugin::getPhysicsResetSignal().trigger( PhysicsResetEvent_Store );
 }
@@ -201,13 +201,13 @@ DefineConsoleFunction( physicsStoreState, void, (), , "physicsStoreState()")
 // Used to send a signal to objects in the
 // physics simulation that they should restore
 // their saved state, such as when the editor is opened.
-DefineConsoleFunction( physicsRestoreState, void, (), , "physicsRestoreState()")
+DefineEngineFunction( physicsRestoreState, void, (), , "physicsRestoreState()")
 {
    if ( PHYSICSMGR )
       PHYSICSMGR->reset();
 }
 
-DefineConsoleFunction( physicsDebugDraw, void, (bool enable), , "physicsDebugDraw( bool enable )")
+DefineEngineFunction( physicsDebugDraw, void, (bool enable), , "physicsDebugDraw( bool enable )")
 {
    if ( PHYSICSMGR )
       PHYSICSMGR->enableDebugDraw( enable );

Engine/source/app/game.cpp

@@ -67,7 +67,7 @@ bool gEditingMission = false;
 
 ConsoleFunctionGroupBegin( InputManagement, "Functions that let you deal with input from scripts" );
 
-DefineConsoleFunction( deactivateDirectInput, void, (), ,
+DefineEngineFunction( deactivateDirectInput, void, (), ,
          "()"
             "@brief Disables DirectInput.\n\n"
             "Also deactivates any connected joysticks.\n\n"
@@ -77,7 +77,7 @@ DefineConsoleFunction( deactivateDirectInput, void, (), ,
       Input::deactivate();
 }
 
-DefineConsoleFunction( activateDirectInput, void, (), ,
+DefineEngineFunction( activateDirectInput, void, (), ,
             "()"
             "@brief Activates DirectInput.\n\n"
             "Also activates any connected joysticks."
@@ -91,7 +91,7 @@ ConsoleFunctionGroupEnd( InputManagement );
 //--------------------------------------------------------------------------
 
 static const U32 MaxPlayerNameLength = 16;
-DefineConsoleFunction( strToPlayerName, const char*, (const char* ptr ), , "strToPlayerName(string);" )
+DefineEngineFunction( strToPlayerName, const char*, (const char* ptr ), , "strToPlayerName(string);" )
 {
 
 	// Strip leading spaces and underscores:
@@ -147,7 +147,7 @@ DefineConsoleFunction( strToPlayerName, const char*, (const char* ptr ), , "strT
 
 ConsoleFunctionGroupBegin( Platform , "General platform functions.");
 
-DefineConsoleFunction( lockMouse, void, (bool isLocked ), , "(bool isLocked)" 
+DefineEngineFunction( lockMouse, void, (bool isLocked ), , "(bool isLocked)"
             "@brief Lock or unlock the mouse to the window.\n\n"
             "When true, prevents the mouse from leaving the bounds of the game window.\n\n"
             "@ingroup Input")
@@ -156,7 +156,7 @@ DefineConsoleFunction( lockMouse, void, (bool isLocked ), , "(bool isLocked)"
 }
 
 
-DefineConsoleFunction( setNetPort, bool, (int port, bool bind), (true), "(int port, bool bind=true)" 
+DefineEngineFunction( setNetPort, bool, (int port, bool bind), (true), "(int port, bool bind=true)" 
    "@brief Set the network port for the game to use.\n\n"
 
    "@param port The port to use.\n"
@@ -171,28 +171,28 @@ DefineConsoleFunction( setNetPort, bool, (int port, bool bind), (true), "(int po
    return Net::openPort((S32)port, bind);
 }
 
-DefineConsoleFunction(isAddressTypeAvailable, bool, (int addressType), , "(protocol id)"
+DefineEngineFunction(isAddressTypeAvailable, bool, (int addressType), , "(protocol id)"
 	"@brief Determines if a specified address type can be reached.\n\n"
 	"@ingroup Networking")
 {
 	return Net::isAddressTypeAvailable((NetAddress::Type)addressType);
 }
 
-DefineConsoleFunction( closeNetPort, void, (), , "()" 
+DefineEngineFunction( closeNetPort, void, (), , "()" 
    "@brief Closes the current network port\n\n"
    "@ingroup Networking")
 {
    Net::closePort();
 }
 
-DefineConsoleFunction( saveJournal, void, (const char * filename), , "(string filename)" 
+DefineEngineFunction( saveJournal, void, (const char * filename), , "(string filename)" 
                 "Save the journal to the specified file.\n\n"
 				"@ingroup Platform")
 {
    Journal::Record(filename);
 }
 
-DefineConsoleFunction( playJournal, void, (const char * filename), , "(string filename)" 
+DefineEngineFunction( playJournal, void, (const char * filename), , "(string filename)" 
                 "@brief Begin playback of a journal from a specified field.\n\n"
 				"@param filename Name and path of file journal file\n"
 				"@ingroup Platform")
@@ -202,7 +202,7 @@ DefineConsoleFunction( playJournal, void, (const char * filename), , "(string fi
    Journal::Play(filename);
 }
 
-DefineConsoleFunction( getSimTime, S32, (), , "()" 
+DefineEngineFunction( getSimTime, S32, (), , "()" 
 				"Return the current sim time in milliseconds.\n\n"
                 "@brief Sim time is time since the game started.\n\n"
 				"@ingroup Platform")
@@ -210,7 +210,7 @@ DefineConsoleFunction( getSimTime, S32, (), , "()"
    return Sim::getCurrentTime();
 }
 
-DefineConsoleFunction( getRealTime, S32, (), , "()" 
+DefineEngineFunction( getRealTime, S32, (), , "()" 
 				"@brief Return the current real time in milliseconds.\n\n"
                 "Real time is platform defined; typically time since the computer booted.\n\n"
 				"@ingroup Platform")

Engine/source/app/net/serverQuery.cpp

@@ -429,7 +429,7 @@ void queryLanServers(U32 port, U8 flags, const char* gameType, const char* missi
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( queryAllServers
+DefineEngineFunction( queryAllServers
                      , void, ( U32 lanPort
                              , U32 flags
                              , const char * gameType
@@ -455,7 +455,7 @@ DefineConsoleFunction( queryAllServers
 
 }
 
-DefineConsoleFunction( queryLanServers
+DefineEngineFunction( queryLanServers
                      , void, ( U32 lanPort
                              , U32 flags
                              , const char * gameType
@@ -560,7 +560,7 @@ void queryMasterServer(U8 flags, const char* gameType, const char* missionType,
       processMasterServerQuery( gPingSession );
 }
 
-DefineConsoleFunction( queryMasterServer
+DefineEngineFunction( queryMasterServer
                      , void, (  U32 flags
                              , const char * gameType
                              , const char * missionType
@@ -582,7 +582,7 @@ DefineConsoleFunction( queryMasterServer
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( querySingleServer
+DefineEngineFunction( querySingleServer
                      , void, ( const char* addrText, U8 flags )
                      , (0), "querySingleServer(address, flags);" )
 {
@@ -668,7 +668,7 @@ void cancelServerQuery()
    }
 }
 
-DefineConsoleFunction( cancelServerQuery, void, (), , "cancelServerQuery();" )
+DefineEngineFunction( cancelServerQuery, void, (), , "cancelServerQuery();" )
 {
    cancelServerQuery();
 }
@@ -696,14 +696,14 @@ void stopServerQuery()
    }
 }
 
-DefineConsoleFunction( stopServerQuery, void, (), , "stopServerQuery();" )
+DefineEngineFunction( stopServerQuery, void, (), , "stopServerQuery();" )
 {
    stopServerQuery();
 }
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( startHeartbeat, void, (), , "startHeartbeat();" )
+DefineEngineFunction( startHeartbeat, void, (), , "startHeartbeat();" )
 {
    if (validateAuthenticatedServer()) {
       gHeartbeatSeq++;
@@ -711,19 +711,19 @@ DefineConsoleFunction( startHeartbeat, void, (), , "startHeartbeat();" )
    }
 }
 
-DefineConsoleFunction( stopHeartbeat, void, (), , "stopHeartbeat();" )
+DefineEngineFunction( stopHeartbeat, void, (), , "stopHeartbeat();" )
 {
    gHeartbeatSeq++;
 }
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getServerCount, int, (), , "getServerCount();" )
+DefineEngineFunction( getServerCount, int, (), , "getServerCount();" )
 {
    return gServerList.size();
 }
 
-DefineConsoleFunction( setServerInfo, bool, (U32 index), , "setServerInfo(index);" )
+DefineEngineFunction( setServerInfo, bool, (U32 index), , "setServerInfo(index);" )
 {
    if (index < gServerList.size()) {
       ServerInfo& info = gServerList[index];

Engine/source/app/version.cpp

@@ -92,44 +92,44 @@ const char* getCompileTimeString()
 
 ConsoleFunctionGroupBegin( CompileInformation, "Functions to get version information about the current executable." );
 
-DefineConsoleFunction( getVersionNumber, S32, (), , "Get the version of the engine build, as a string.\n\n" 
+DefineEngineFunction( getVersionNumber, S32, (), , "Get the version of the engine build, as a string.\n\n" 
 				"@ingroup Debugging")
 {
    return getVersionNumber();
 }
 
-DefineConsoleFunction( getAppVersionNumber, S32, (), , "Get the version of the application build, as a string.\n\n" 
+DefineEngineFunction( getAppVersionNumber, S32, (), , "Get the version of the application build, as a string.\n\n" 
             "@ingroup Debugging")
 {
    return getAppVersionNumber();
 }
 
 
-DefineConsoleFunction( getVersionString, const char*, (), , "Get the version of the engine build, as a human readable string.\n\n" 
+DefineEngineFunction( getVersionString, const char*, (), , "Get the version of the engine build, as a human readable string.\n\n" 
 				"@ingroup Debugging")
 {
    return getVersionString();
 }
 
-DefineConsoleFunction( getAppVersionString, const char*, (), , "Get the version of the aplication build, as a human readable string.\n\n" 
+DefineEngineFunction( getAppVersionString, const char*, (), , "Get the version of the aplication build, as a human readable string.\n\n" 
             "@ingroup Debugging")
 {
    return getAppVersionString();
 }
 
-DefineConsoleFunction( getEngineName, const char*, (), , "Get the name of the engine product that this is running from, as a string.\n\n" 
+DefineEngineFunction( getEngineName, const char*, (), , "Get the name of the engine product that this is running from, as a string.\n\n" 
 				"@ingroup Debugging")
 {
    return getEngineProductString();
 }
 
-DefineConsoleFunction( getCompileTimeString, const char*, (), , "Get the time of compilation.\n\n" 
+DefineEngineFunction( getCompileTimeString, const char*, (), , "Get the time of compilation.\n\n" 
 				"@ingroup Debugging")
 {
    return getCompileTimeString();
 }
 
-DefineConsoleFunction( getBuildString, const char*, (), , "Get the type of build, \"Debug\" or \"Release\".\n\n"
+DefineEngineFunction( getBuildString, const char*, (), , "Get the type of build, \"Debug\" or \"Release\".\n\n"
 				"@ingroup Debugging")
 {
 #ifdef TORQUE_DEBUG

Engine/source/assets/assetQuery_ScriptBinding.h

@@ -26,7 +26,7 @@
 
 #include "console/engineAPI.h"
 
-DefineConsoleMethod(AssetQuery, clear, void, (),,"Clears all asset Id results."
+DefineEngineMethod(AssetQuery, clear, void, (),,"Clears all asset Id results."
    "Clears all asset Id results.\n"
    "@return () No return value.\n")
 {
@@ -36,7 +36,7 @@ DefineConsoleMethod(AssetQuery, clear, void, (),,"Clears all asset Id results."
 //-----------------------------------------------------------------------------
 
 
-DefineConsoleMethod(AssetQuery, set, bool, (S32 queryId), ,
+DefineEngineMethod(AssetQuery, set, bool, (S32 queryId), ,
    "Sets the asset query to a copy of the specified asset query.\n"
    "@param assetQuery The asset query to copy.\n"
    "@return Whether the operation succeeded or not.\n")

Engine/source/cinterface/cinterface.cpp

@@ -436,7 +436,7 @@ extern "C" {
 // By default, it is marked as secure by the web plugins and then can be called from
 // Javascript on the web page to ensure that function calls across the language
 // boundry are working with arguments and return values
-DefineConsoleFunction( testJavaScriptBridge, const char *, (const char* arg1, const char* arg2, const char* arg3), , "testBridge(arg1, arg2, arg3)")
+DefineEngineFunction( testJavaScriptBridge, const char *, (const char* arg1, const char* arg2, const char* arg3), , "testBridge(arg1, arg2, arg3)")
 {
 	S32 failed = 0;
 		if (dStrcmp(arg1,"one"))

Engine/source/console/console.cpp

@@ -277,7 +277,7 @@ bool useTimestamp = false;
 
 ConsoleFunctionGroupBegin( Clipboard, "Miscellaneous functions to control the clipboard and clear the console.");
 
-DefineConsoleFunction( cls, void, (), , "()"
+DefineEngineFunction( cls, void, (), , "()"
             "@brief Clears the console output.\n\n"
             "@ingroup Console")
 {
@@ -287,14 +287,14 @@ DefineConsoleFunction( cls, void, (), , "()"
    consoleLog.setSize(0);
 };
 
-DefineConsoleFunction( getClipboard, const char*, (), , "()"
+DefineEngineFunction( getClipboard, const char*, (), , "()"
             "@brief Get text from the clipboard.\n\n"
             "@internal")
 {
    return Platform::getClipboard();
 };
 
-DefineConsoleFunction( setClipboard, bool, (const char* text), , "(string text)"
+DefineEngineFunction( setClipboard, bool, (const char* text), , "(string text)"
                "@brief Set the system clipboard.\n\n"
             "@internal")
 {

Engine/source/console/consoleDoc.cpp

@@ -41,7 +41,7 @@
 
 ConsoleFunctionGroupBegin(ConsoleDoc, "Console self-documentation functions. These output psuedo C++ suitable for feeeding through Doxygen or another auto documentation tool.");
 
-DefineConsoleFunction( dumpConsoleClasses, void, (bool dumpScript, bool dumpEngine), ( true, true ),
+DefineEngineFunction( dumpConsoleClasses, void, (bool dumpScript, bool dumpEngine), ( true, true ),
             "@brief Dumps all declared console classes to the console.\n\n"
             "@param dumpScript Optional parameter specifying whether or not classes defined in script should be dumped.\n"
             "@param dumpEngine Optional parameter specifying whether or not classes defined in the engine should be dumped.\n"
@@ -50,7 +50,7 @@ DefineConsoleFunction( dumpConsoleClasses, void, (bool dumpScript, bool dumpEngi
    Namespace::dumpClasses( dumpScript, dumpEngine );
 }
 
-DefineConsoleFunction(dumpConsoleFunctions, void, ( bool dumpScript, bool dumpEngine ), ( true, true ),
+DefineEngineFunction(dumpConsoleFunctions, void, ( bool dumpScript, bool dumpEngine ), ( true, true ),
             "@brief Dumps all declared console functions to the console.\n"
             "@param dumpScript Optional parameter specifying whether or not functions defined in script should be dumped.\n"
             "@param dumpEngine Optional parameter specitying whether or not functions defined in the engine should be dumped.\n"

Engine/source/console/consoleFunctions.cpp

@@ -184,7 +184,7 @@ bool isValidPort(U16 port)
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( strasc, int, ( const char* chr ),,
+DefineEngineFunction( strasc, int, ( const char* chr ),,
    "Return the integer character code value corresponding to the first character in the given string.\n"
    "@param chr a (one-character) string.\n"
    "@return the UTF32 code value for the first character in the given string.\n"
@@ -195,7 +195,7 @@ DefineConsoleFunction( strasc, int, ( const char* chr ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( strformat, const char*, ( const char* format, const char* value ),,
+DefineEngineFunction( strformat, const char*, ( const char* format, const char* value ),,
    "Format the given value as a string using printf-style formatting.\n"
    "@param format A printf-style format string.\n"
    "@param value The value argument matching the given format string.\n\n"
@@ -252,7 +252,7 @@ DefineConsoleFunction( strformat, const char*, ( const char* format, const char*
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( strcmp, S32, ( const char* str1, const char* str2 ),,
+DefineEngineFunction( strcmp, S32, ( const char* str1, const char* str2 ),,
    "Compares two strings using case-<b>sensitive</b> comparison.\n"
    "@param str1 The first string.\n"
    "@param str2 The second string.\n"
@@ -271,7 +271,7 @@ DefineConsoleFunction( strcmp, S32, ( const char* str1, const char* str2 ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( stricmp, S32, ( const char* str1, const char* str2 ),,
+DefineEngineFunction( stricmp, S32, ( const char* str1, const char* str2 ),,
    "Compares two strings using case-<b>insensitive</b> comparison.\n"
    "@param str1 The first string.\n"
    "@param str2 The second string.\n"
@@ -290,7 +290,7 @@ DefineConsoleFunction( stricmp, S32, ( const char* str1, const char* str2 ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( strnatcmp, S32, ( const char* str1, const char* str2 ),,
+DefineEngineFunction( strnatcmp, S32, ( const char* str1, const char* str2 ),,
    "Compares two strings using \"natural order\" case-<b>sensitive</b> comparison.\n"
    "Natural order means that rather than solely comparing single character code values, strings are ordered in a "
    "natural way.  For example, the string \"hello10\" is considered greater than the string \"hello2\" even though "
@@ -325,7 +325,7 @@ DefineConsoleFunction( strnatcmp, S32, ( const char* str1, const char* str2 ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( strinatcmp, S32, ( const char* str1, const char* str2 ),,
+DefineEngineFunction( strinatcmp, S32, ( const char* str1, const char* str2 ),,
    "Compares two strings using \"natural order\" case-<b>insensitive</b> comparison.\n"
    "Natural order means that rather than solely comparing single character code values, strings are ordered in a "
    "natural way.  For example, the string \"hello10\" is considered greater than the string \"hello2\" even though "
@@ -360,7 +360,7 @@ DefineConsoleFunction( strinatcmp, S32, ( const char* str1, const char* str2 ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( strlen, S32, ( const char* str ),,
+DefineEngineFunction( strlen, S32, ( const char* str ),,
    "Get the length of the given string in bytes.\n"
    "@note This does <b>not</b> return a true character count for strings with multi-byte characters!\n"
    "@param str A string.\n"
@@ -371,7 +371,7 @@ DefineConsoleFunction( strlen, S32, ( const char* str ),,
 }
 
 //-----------------------------------------------------------------------------
-DefineConsoleFunction( strlenskip, S32, ( const char* str, const char* first, const char* last ),,
+DefineEngineFunction( strlenskip, S32, ( const char* str, const char* first, const char* last ),,
    "Calculate the length of a string in characters, skipping everything between and including first and last.\n"
    "@param str A string.\n"
    "@param first First character to look for to skip block of text.\n"
@@ -406,7 +406,7 @@ DefineConsoleFunction( strlenskip, S32, ( const char* str, const char* first, co
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( strstr, S32, ( const char* string, const char* substring ),,
+DefineEngineFunction( strstr, S32, ( const char* string, const char* substring ),,
    "Find the start of @a substring in the given @a string searching from left to right.\n"
    "@param string The string to search.\n"
    "@param substring The string to search for.\n"
@@ -425,7 +425,7 @@ DefineConsoleFunction( strstr, S32, ( const char* string, const char* substring
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( strpos, S32, ( const char* haystack, const char* needle, S32 offset ), ( 0 ),
+DefineEngineFunction( strpos, S32, ( const char* haystack, const char* needle, S32 offset ), ( 0 ),
    "Find the start of @a needle in @a haystack searching from left to right beginning at the given offset.\n"
    "@param haystack The string to search.\n"
    "@param needle The string to search for.\n"
@@ -450,7 +450,7 @@ DefineConsoleFunction( strpos, S32, ( const char* haystack, const char* needle,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( strposr, S32, ( const char* haystack, const char* needle, S32 offset ), ( 0 ),
+DefineEngineFunction( strposr, S32, ( const char* haystack, const char* needle, S32 offset ), ( 0 ),
    "Find the start of @a needle in @a haystack searching from right to left beginning at the given offset.\n"
    "@param haystack The string to search.\n"
    "@param needle The string to search for.\n"
@@ -477,7 +477,7 @@ DefineConsoleFunction( strposr, S32, ( const char* haystack, const char* needle,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( ltrim, const char*, ( const char* str ),,
+DefineEngineFunction( ltrim, const char*, ( const char* str ),,
    "Remove leading whitespace from the string.\n"
    "@param str A string.\n"
    "@return A string that is the same as @a str but with any leading (i.e. leftmost) whitespace removed.\n\n"
@@ -496,7 +496,7 @@ DefineConsoleFunction( ltrim, const char*, ( const char* str ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( rtrim, const char*, ( const char* str ),,
+DefineEngineFunction( rtrim, const char*, ( const char* str ),,
    "Remove trailing whitespace from the string.\n"
    "@param str A string.\n"
    "@return A string that is the same as @a str but with any trailing (i.e. rightmost) whitespace removed.\n\n"
@@ -523,7 +523,7 @@ DefineConsoleFunction( rtrim, const char*, ( const char* str ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( trim, const char*, ( const char* str ),,
+DefineEngineFunction( trim, const char*, ( const char* str ),,
    "Remove leading and trailing whitespace from the string.\n"
    "@param str A string.\n"
    "@return A string that is the same as @a str but with any leading (i.e. leftmost) and trailing (i.e. rightmost) whitespace removed.\n\n"
@@ -551,7 +551,7 @@ DefineConsoleFunction( trim, const char*, ( const char* str ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( stripChars, const char*, ( const char* str, const char* chars ),,
+DefineEngineFunction( stripChars, const char*, ( const char* str, const char* chars ),,
    "Remove all occurrences of characters contained in @a chars from @a str.\n"
    "@param str The string to filter characters out from.\n"
    "@param chars A string of characters to filter out from @a str.\n"
@@ -575,7 +575,7 @@ DefineConsoleFunction( stripChars, const char*, ( const char* str, const char* c
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( strlwr, const char*, ( const char* str ),,
+DefineEngineFunction( strlwr, const char*, ( const char* str ),,
    "Return an all lower-case version of the given string.\n"
    "@param str A string.\n"
    "@return A version of @a str with all characters converted to lower-case.\n\n"
@@ -593,7 +593,7 @@ DefineConsoleFunction( strlwr, const char*, ( const char* str ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( strupr, const char*, ( const char* str ),,
+DefineEngineFunction( strupr, const char*, ( const char* str ),,
    "Return an all upper-case version of the given string.\n"
    "@param str A string.\n"
    "@return A version of @a str with all characters converted to upper-case.\n\n"
@@ -611,7 +611,7 @@ DefineConsoleFunction( strupr, const char*, ( const char* str ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( strchr, const char*, ( const char* str, const char* chr ),,
+DefineEngineFunction( strchr, const char*, ( const char* str, const char* chr ),,
    "Find the first occurrence of the given character in @a str.\n"
    "@param str The string to search.\n"
    "@param chr The character to search for.  Only the first character from the string is taken.\n"
@@ -625,7 +625,7 @@ DefineConsoleFunction( strchr, const char*, ( const char* str, const char* chr )
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( strrchr, const char*, ( const char* str, const char* chr ),,
+DefineEngineFunction( strrchr, const char*, ( const char* str, const char* chr ),,
    "Find the last occurrence of the given character in @a str."
    "@param str The string to search.\n"
    "@param chr The character to search for.  Only the first character from the string is taken.\n"
@@ -639,7 +639,7 @@ DefineConsoleFunction( strrchr, const char*, ( const char* str, const char* chr
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( strreplace, const char*, ( const char* source, const char* from, const char* to ),,
+DefineEngineFunction( strreplace, const char*, ( const char* source, const char* from, const char* to ),,
    "Replace all occurrences of @a from in @a source with @a to.\n"
    "@param source The string in which to replace the occurrences of @a from.\n"
    "@param from The string to replace in @a source.\n"
@@ -690,7 +690,7 @@ DefineConsoleFunction( strreplace, const char*, ( const char* source, const char
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( strrepeat, const char*, ( const char* str, S32 numTimes, const char* delimiter ), ( "" ),
+DefineEngineFunction( strrepeat, const char*, ( const char* str, S32 numTimes, const char* delimiter ), ( "" ),
    "Return a string that repeats @a str @a numTimes number of times delimiting each occurrence with @a delimiter.\n"
    "@param str The string to repeat multiple times.\n"
    "@param numTimes The number of times to repeat @a str in the result string.\n"
@@ -717,7 +717,7 @@ DefineConsoleFunction( strrepeat, const char*, ( const char* str, S32 numTimes,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getSubStr, const char*, ( const char* str, S32 start, S32 numChars ), ( -1 ),
+DefineEngineFunction( getSubStr, const char*, ( const char* str, S32 start, S32 numChars ), ( -1 ),
    "@brief Return a substring of @a str starting at @a start and continuing either through to the end of @a str "
    "(if @a numChars is -1) or for @a numChars characters (except if this would exceed the actual source "
    "string length).\n"
@@ -758,7 +758,7 @@ DefineConsoleFunction( getSubStr, const char*, ( const char* str, S32 start, S32
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( strIsMatchExpr, bool, ( const char* pattern, const char* str, bool caseSensitive ), ( false ),
+DefineEngineFunction( strIsMatchExpr, bool, ( const char* pattern, const char* str, bool caseSensitive ), ( false ),
    "Match a pattern against a string.\n"
    "@param pattern The wildcard pattern to match against.  The pattern can include characters, '*' to match "
       "any number of characters and '?' to match a single character.\n"
@@ -777,7 +777,7 @@ DefineConsoleFunction( strIsMatchExpr, bool, ( const char* pattern, const char*
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( strIsMatchMultipleExpr, bool, ( const char* patterns, const char* str, bool caseSensitive ), ( false ),
+DefineEngineFunction( strIsMatchMultipleExpr, bool, ( const char* patterns, const char* str, bool caseSensitive ), ( false ),
    "Match a multiple patterns against a single string.\n"
    "@param patterns A tab-separated list of patterns.  Each pattern can include charaters, '*' to match "
       "any number of characters and '?' to match a single character.  Each of the patterns is tried in turn.\n"
@@ -796,7 +796,7 @@ DefineConsoleFunction( strIsMatchMultipleExpr, bool, ( const char* patterns, con
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getTrailingNumber, S32, ( const char* str ),,
+DefineEngineFunction( getTrailingNumber, S32, ( const char* str ),,
    "Get the numeric suffix of the given input string.\n"
    "@param str The string from which to read out the numeric suffix.\n"
    "@return The numeric value of the number suffix of @a str or -1 if @a str has no such suffix.\n\n"
@@ -813,7 +813,7 @@ DefineConsoleFunction( getTrailingNumber, S32, ( const char* str ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( stripTrailingNumber, String, ( const char* str ),,
+DefineEngineFunction( stripTrailingNumber, String, ( const char* str ),,
    "Strip a numeric suffix from the given string.\n"
    "@param str The string from which to strip its numeric suffix.\n"
    "@return The string @a str without its number suffix or the original string @a str if it has no such suffix.\n\n"
@@ -829,7 +829,7 @@ DefineConsoleFunction( stripTrailingNumber, String, ( const char* str ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getFirstNumber, String, ( const char* str ),,
+DefineEngineFunction( getFirstNumber, String, ( const char* str ),,
    "Get the first occuring number from @a str.\n"
    "@param str The string from which to read out the first number.\n"
    "@return String representation of the number or "" if no number.\n\n")
@@ -841,7 +841,7 @@ DefineConsoleFunction( getFirstNumber, String, ( const char* str ),,
 
 //----------------------------------------------------------------
 
-DefineConsoleFunction( isspace, bool, ( const char* str, S32 index ),,
+DefineEngineFunction( isspace, bool, ( const char* str, S32 index ),,
    "Test whether the character at the given position is a whitespace character.\n"
    "Characters such as tab, space, or newline are considered whitespace.\n"
    "@param str The string to test.\n"
@@ -858,7 +858,7 @@ DefineConsoleFunction( isspace, bool, ( const char* str, S32 index ),,
 
 //----------------------------------------------------------------
 
-DefineConsoleFunction( isalnum, bool, ( const char* str, S32 index ),,
+DefineEngineFunction( isalnum, bool, ( const char* str, S32 index ),,
    "Test whether the character at the given position is an alpha-numeric character.\n"
    "Alpha-numeric characters are characters that are either alphabetic (a-z, A-Z) or numbers (0-9).\n"
    "@param str The string to test.\n"
@@ -875,7 +875,7 @@ DefineConsoleFunction( isalnum, bool, ( const char* str, S32 index ),,
 
 //----------------------------------------------------------------
 
-DefineConsoleFunction( startsWith, bool, ( const char* str, const char* prefix, bool caseSensitive ), ( false ),
+DefineEngineFunction( startsWith, bool, ( const char* str, const char* prefix, bool caseSensitive ), ( false ),
    "Test whether the given string begins with the given prefix.\n"
    "@param str The string to test.\n"
    "@param prefix The potential prefix of @a str.\n"
@@ -924,7 +924,7 @@ DefineConsoleFunction( startsWith, bool, ( const char* str, const char* prefix,
 
 //----------------------------------------------------------------
 
-DefineConsoleFunction( endsWith, bool, ( const char* str, const char* suffix, bool caseSensitive ), ( false ),
+DefineEngineFunction( endsWith, bool, ( const char* str, const char* suffix, bool caseSensitive ), ( false ),
    "@brief Test whether the given string ends with the given suffix.\n\n"
    "@param str The string to test.\n"
    "@param suffix The potential suffix of @a str.\n"
@@ -978,7 +978,7 @@ DefineConsoleFunction( endsWith, bool, ( const char* str, const char* suffix, bo
 
 //----------------------------------------------------------------
 
-DefineConsoleFunction( strchrpos, S32, ( const char* str, const char* chr, S32 start ), ( 0 ),
+DefineEngineFunction( strchrpos, S32, ( const char* str, const char* chr, S32 start ), ( 0 ),
    "Find the first occurrence of the given character in the given string.\n"
    "@param str The string to search.\n"
    "@param chr The character to look for.  Only the first character of this string will be searched for.\n"
@@ -998,7 +998,7 @@ DefineConsoleFunction( strchrpos, S32, ( const char* str, const char* chr, S32 s
 
 //----------------------------------------------------------------
 
-DefineConsoleFunction( strrchrpos, S32, ( const char* str, const char* chr, S32 start ), ( 0 ),
+DefineEngineFunction( strrchrpos, S32, ( const char* str, const char* chr, S32 start ), ( 0 ),
    "Find the last occurrence of the given character in the given string.\n"
    "@param str The string to search.\n"
    "@param chr The character to look for.  Only the first character of this string will be searched for.\n"
@@ -1025,7 +1025,7 @@ DefineConsoleFunction( strrchrpos, S32, ( const char* str, const char* chr, S32
 
 //----------------------------------------------------------------
 
-DefineConsoleFunction(ColorFloatToInt, ColorI, (LinearColorF color), ,
+DefineEngineFunction(ColorFloatToInt, ColorI, (LinearColorF color), ,
    "Convert from a float color to an integer color (0.0 - 1.0 to 0 to 255).\n"
    "@param color Float color value to be converted in the form \"R G B A\", where R is red, G is green, B is blue, and A is alpha.\n"
    "@return Converted color value (0 - 255)\n\n"
@@ -1037,7 +1037,7 @@ DefineConsoleFunction(ColorFloatToInt, ColorI, (LinearColorF color), ,
    return color.toColorI();
 }
 
-DefineConsoleFunction(ColorIntToFloat, LinearColorF, (ColorI color), ,
+DefineEngineFunction(ColorIntToFloat, LinearColorF, (ColorI color), ,
    "Convert from a integer color to an float color (0 to 255 to 0.0 - 1.0).\n"
    "@param color Integer color value to be converted in the form \"R G B A\", where R is red, G is green, B is blue, and A is alpha.\n"
    "@return Converted color value (0.0 - 1.0)\n\n"
@@ -1049,7 +1049,7 @@ DefineConsoleFunction(ColorIntToFloat, LinearColorF, (ColorI color), ,
    return LinearColorF(color);
 }
 
-DefineConsoleFunction(ColorRGBToHEX, const char*, (ColorI color), ,
+DefineEngineFunction(ColorRGBToHEX, const char*, (ColorI color), ,
    "Convert from a integer RGB (red, green, blue) color to hex color value (0 to 255 to 00 - FF).\n"
    "@param color Integer color value to be converted in the form \"R G B A\", where R is red, G is green, B is blue, and A is alpha. It excepts an alpha, but keep in mind this will not be converted.\n"
    "@return Hex color value (#000000 - #FFFFFF), alpha isn't handled/converted so it is only the RGB value\n\n"
@@ -1061,7 +1061,7 @@ DefineConsoleFunction(ColorRGBToHEX, const char*, (ColorI color), ,
    return Con::getReturnBuffer(color.getHex());
 }
 
-DefineConsoleFunction(ColorRGBToHSB, const char*, (ColorI color), ,
+DefineEngineFunction(ColorRGBToHSB, const char*, (ColorI color), ,
    "Convert from a integer RGB (red, green, blue) color to HSB (hue, saturation, brightness). HSB is also know as HSL or HSV as well, with the last letter standing for lightness or value.\n"
    "@param color Integer color value to be converted in the form \"R G B A\", where R is red, G is green, B is blue, and A is alpha. It excepts an alpha, but keep in mind this will not be converted.\n"
    "@return HSB color value, alpha isn't handled/converted so it is only the RGB value\n\n"
@@ -1075,7 +1075,7 @@ DefineConsoleFunction(ColorRGBToHSB, const char*, (ColorI color), ,
    return Con::getReturnBuffer(s);
 }
 
-DefineConsoleFunction(ColorHEXToRGB, ColorI, (const char* hex), ,
+DefineEngineFunction(ColorHEXToRGB, ColorI, (const char* hex), ,
    "Convert from a hex color value to an integer RGB (red, green, blue) color (00 - FF to 0 to 255).\n"
    "@param hex Hex color value (#000000 - #FFFFFF) to be converted to an RGB (red, green, blue) value.\n"
    "@return Integer color value to be converted in the form \"R G B A\", where R is red, G is green, B is blue, and A is alpha. Alpha isn't handled/converted so only pay attention to the RGB value\n\n"
@@ -1089,7 +1089,7 @@ DefineConsoleFunction(ColorHEXToRGB, ColorI, (const char* hex), ,
    return color;
 }
 
-DefineConsoleFunction(ColorHSBToRGB, ColorI, (Point3I hsb), ,
+DefineEngineFunction(ColorHSBToRGB, ColorI, (Point3I hsb), ,
    "Convert from a HSB (hue, saturation, brightness) to an integer RGB (red, green, blue) color. HSB is also know as HSL or HSV as well, with the last letter standing for lightness or value.\n"
    "@param hsb HSB (hue, saturation, brightness) value to be converted.\n"
    "@return Integer color value to be converted in the form \"R G B A\", where R is red, G is green, B is blue, and A is alpha. Alpha isn't handled/converted so only pay attention to the RGB value\n\n"
@@ -1105,7 +1105,7 @@ DefineConsoleFunction(ColorHSBToRGB, ColorI, (Point3I hsb), ,
 
 //----------------------------------------------------------------
 
-DefineConsoleFunction( strToggleCaseToWords, const char*, ( const char* str ),,
+DefineEngineFunction( strToggleCaseToWords, const char*, ( const char* str ),,
    "Parse a Toggle Case word into separate words.\n"
    "@param str The string to parse.\n"
    "@return new string space separated.\n\n"
@@ -1130,7 +1130,7 @@ DefineConsoleFunction( strToggleCaseToWords, const char*, ( const char* str ),,
 //----------------------------------------------------------------
 
 // Warning: isInt and isFloat are very 'strict' and might need to be adjusted to allow other values. //seanmc
-DefineConsoleFunction( isInt, bool, ( const char* str),,
+DefineEngineFunction( isInt, bool, ( const char* str),,
    "Returns true if the string is an integer.\n"
    "@param str The string to test.\n"
    "@return true if @a str is an integer and false if not\n\n"
@@ -1144,7 +1144,7 @@ DefineConsoleFunction( isInt, bool, ( const char* str),,
 
 //----------------------------------------------------------------
 
-DefineConsoleFunction( isFloat, bool, ( const char* str, bool sciOk), (false),
+DefineEngineFunction( isFloat, bool, ( const char* str, bool sciOk), (false),
    "Returns true if the string is a float.\n"
    "@param str The string to test.\n"
    "@param sciOk Test for correct scientific notation and accept it (ex. 1.2e+14)"
@@ -1159,7 +1159,7 @@ DefineConsoleFunction( isFloat, bool, ( const char* str, bool sciOk), (false),
 
 //----------------------------------------------------------------
 
-DefineConsoleFunction( isValidPort, bool, ( const char* str),,
+DefineEngineFunction( isValidPort, bool, ( const char* str),,
    "Returns true if the string is a valid port number.\n"
    "@param str The string to test.\n"
    "@return true if @a str is a port and false if not\n\n"
@@ -1179,7 +1179,7 @@ DefineConsoleFunction( isValidPort, bool, ( const char* str),,
 
 //----------------------------------------------------------------
 
-DefineConsoleFunction( isValidIP, bool, ( const char* str),,
+DefineEngineFunction( isValidIP, bool, ( const char* str),,
    "Returns true if the string is a valid ip address, excepts localhost.\n"
    "@param str The string to test.\n"
    "@return true if @a str is a valid ip address and false if not\n\n"
@@ -1214,7 +1214,7 @@ ConsoleFunction(addCaseSensitiveStrings,void,2,0,"[string1, string2, ...]"
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getWord, const char*, ( const char* text, S32 index ),,
+DefineEngineFunction( getWord, const char*, ( const char* text, S32 index ),,
    "Extract the word at the given @a index in the whitespace-separated list in @a text.\n"
    "Words in @a text must be separated by newlines, spaces, and/or tabs.\n"
    "@param text A whitespace-separated list of words.\n"
@@ -1235,7 +1235,7 @@ DefineConsoleFunction( getWord, const char*, ( const char* text, S32 index ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getWords, const char*, ( const char* text, S32 startIndex, S32 endIndex ), ( -1 ),
+DefineEngineFunction( getWords, const char*, ( const char* text, S32 startIndex, S32 endIndex ), ( -1 ),
    "Extract a range of words from the given @a startIndex onwards thru @a endIndex.\n"
    "Words in @a text must be separated by newlines, spaces, and/or tabs.\n"
    "@param text A whitespace-separated list of words.\n"
@@ -1262,7 +1262,7 @@ DefineConsoleFunction( getWords, const char*, ( const char* text, S32 startIndex
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( setWord, const char*, ( const char* text, S32 index, const char* replacement ),,
+DefineEngineFunction( setWord, const char*, ( const char* text, S32 index, const char* replacement ),,
    "Replace the word in @a text at the given @a index with @a replacement.\n"
    "Words in @a text must be separated by newlines, spaces, and/or tabs.\n"
    "@param text A whitespace-separated list of words.\n"
@@ -1284,7 +1284,7 @@ DefineConsoleFunction( setWord, const char*, ( const char* text, S32 index, cons
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( removeWord, const char*, ( const char* text, S32 index ),,
+DefineEngineFunction( removeWord, const char*, ( const char* text, S32 index ),,
    "Remove the word in @a text at the given @a index.\n"
    "Words in @a text must be separated by newlines, spaces, and/or tabs.\n"
    "@param text A whitespace-separated list of words.\n"
@@ -1304,7 +1304,7 @@ DefineConsoleFunction( removeWord, const char*, ( const char* text, S32 index ),
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getWordCount, S32, ( const char* text ),,
+DefineEngineFunction( getWordCount, S32, ( const char* text ),,
    "Return the number of whitespace-separated words in @a text.\n"
    "Words in @a text must be separated by newlines, spaces, and/or tabs.\n"
    "@param text A whitespace-separated list of words.\n"
@@ -1365,7 +1365,7 @@ DefineEngineFunction( weekdayNumToStr, String, ( S32 num, bool abbreviate ), (fa
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getField, const char*, ( const char* text, S32 index ),,
+DefineEngineFunction( getField, const char*, ( const char* text, S32 index ),,
    "Extract the field at the given @a index in the newline and/or tab separated list in @a text.\n"
    "Fields in @a text must be separated by newlines and/or tabs.\n"
    "@param text A list of fields separated by newlines and/or tabs.\n"
@@ -1385,7 +1385,7 @@ DefineConsoleFunction( getField, const char*, ( const char* text, S32 index ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getFields, const char*, ( const char* text, S32 startIndex, S32 endIndex ), ( -1 ),
+DefineEngineFunction( getFields, const char*, ( const char* text, S32 startIndex, S32 endIndex ), ( -1 ),
    "Extract a range of fields from the given @a startIndex onwards thru @a endIndex.\n"
    "Fields in @a text must be separated by newlines and/or tabs.\n"
    "@param text A list of fields separated by newlines and/or tabs.\n"
@@ -1411,7 +1411,7 @@ DefineConsoleFunction( getFields, const char*, ( const char* text, S32 startInde
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( setField, const char*, ( const char* text, S32 index, const char* replacement ),,
+DefineEngineFunction( setField, const char*, ( const char* text, S32 index, const char* replacement ),,
    "Replace the field in @a text at the given @a index with @a replacement.\n"
    "Fields in @a text must be separated by newlines and/or tabs.\n"
    "@param text A list of fields separated by newlines and/or tabs.\n"
@@ -1432,7 +1432,7 @@ DefineConsoleFunction( setField, const char*, ( const char* text, S32 index, con
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( removeField, const char*, ( const char* text, S32 index ),,
+DefineEngineFunction( removeField, const char*, ( const char* text, S32 index ),,
    "Remove the field in @a text at the given @a index.\n"
    "Fields in @a text must be separated by newlines and/or tabs.\n"
    "@param text A list of fields separated by newlines and/or tabs.\n"
@@ -1451,7 +1451,7 @@ DefineConsoleFunction( removeField, const char*, ( const char* text, S32 index )
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getFieldCount, S32, ( const char* text ),,
+DefineEngineFunction( getFieldCount, S32, ( const char* text ),,
    "Return the number of newline and/or tab separated fields in @a text.\n"
    "@param text A list of fields separated by newlines and/or tabs.\n"
    "@return The number of newline and/or tab sepearated elements in @a text.\n\n"
@@ -1467,7 +1467,7 @@ DefineConsoleFunction( getFieldCount, S32, ( const char* text ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getRecord, const char*, ( const char* text, S32 index ),,
+DefineEngineFunction( getRecord, const char*, ( const char* text, S32 index ),,
    "Extract the record at the given @a index in the newline-separated list in @a text.\n"
    "Records in @a text must be separated by newlines.\n"
    "@param text A list of records separated by newlines.\n"
@@ -1487,7 +1487,7 @@ DefineConsoleFunction( getRecord, const char*, ( const char* text, S32 index ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getRecords, const char*, ( const char* text, S32 startIndex, S32 endIndex ), ( -1 ),
+DefineEngineFunction( getRecords, const char*, ( const char* text, S32 startIndex, S32 endIndex ), ( -1 ),
    "Extract a range of records from the given @a startIndex onwards thru @a endIndex.\n"
    "Records in @a text must be separated by newlines.\n"
    "@param text A list of records separated by newlines.\n"
@@ -1513,7 +1513,7 @@ DefineConsoleFunction( getRecords, const char*, ( const char* text, S32 startInd
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( setRecord, const char*, ( const char* text, S32 index, const char* replacement ),,
+DefineEngineFunction( setRecord, const char*, ( const char* text, S32 index, const char* replacement ),,
    "Replace the record in @a text at the given @a index with @a replacement.\n"
    "Records in @a text must be separated by newlines.\n"
    "@param text A list of records separated by newlines.\n"
@@ -1534,7 +1534,7 @@ DefineConsoleFunction( setRecord, const char*, ( const char* text, S32 index, co
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( removeRecord, const char*, ( const char* text, S32 index ),,
+DefineEngineFunction( removeRecord, const char*, ( const char* text, S32 index ),,
    "Remove the record in @a text at the given @a index.\n"
    "Records in @a text must be separated by newlines.\n"
    "@param text A list of records separated by newlines.\n"
@@ -1553,7 +1553,7 @@ DefineConsoleFunction( removeRecord, const char*, ( const char* text, S32 index
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getRecordCount, S32, ( const char* text ),,
+DefineEngineFunction( getRecordCount, S32, ( const char* text ),,
    "Return the number of newline-separated records in @a text.\n"
    "@param text A list of records separated by newlines.\n"
    "@return The number of newline-sepearated elements in @a text.\n\n"
@@ -1569,7 +1569,7 @@ DefineConsoleFunction( getRecordCount, S32, ( const char* text ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( firstWord, const char*, ( const char* text ),,
+DefineEngineFunction( firstWord, const char*, ( const char* text ),,
    "Return the first word in @a text.\n"
    "@param text A list of words separated by newlines, spaces, and/or tabs.\n"
    "@return The word at index 0 in @a text or \"\" if @a text is empty.\n\n"
@@ -1585,7 +1585,7 @@ DefineConsoleFunction( firstWord, const char*, ( const char* text ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( restWords, const char*, ( const char* text ),,
+DefineEngineFunction( restWords, const char*, ( const char* text ),,
    "Return all but the first word in @a text.\n"
    "@param text A list of words separated by newlines, spaces, and/or tabs.\n"
    "@return @a text with the first word removed.\n\n"
@@ -1619,7 +1619,7 @@ static bool isInSet(char c, const char *set)
    return false;
 }
 
-DefineConsoleFunction( nextToken, const char*, ( const char* str1, const char* token, const char* delim), , "( string str, string token, string delimiters ) "
+DefineEngineFunction( nextToken, const char*, ( const char* str1, const char* token, const char* delim), , "( string str, string token, string delimiters ) "
    "Tokenize a string using a set of delimiting characters.\n"
    "This function first skips all leading charaters in @a str that are contained in @a delimiters. "
    "From that position, it then scans for the next character in @a str that is contained in @a delimiters and stores all characters "
@@ -1688,7 +1688,7 @@ DefineConsoleFunction( nextToken, const char*, ( const char* str1, const char* t
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getToken, const char*, ( const char* text, const char* delimiters, S32 index ),,
+DefineEngineFunction( getToken, const char*, ( const char* text, const char* delimiters, S32 index ),,
    "Extract the substring at the given @a index in the @a delimiters separated list in @a text.\n"
    "@param text A @a delimiters list of substrings.\n"
    "@param delimiters Character or characters that separate the list of substrings in @a text.\n"
@@ -1709,7 +1709,7 @@ DefineConsoleFunction( getToken, const char*, ( const char* text, const char* de
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getTokens, const char*, ( const char* text, const char* delimiters, S32 startIndex, S32 endIndex ), ( -1 ),
+DefineEngineFunction( getTokens, const char*, ( const char* text, const char* delimiters, S32 startIndex, S32 endIndex ), ( -1 ),
    "Extract a range of substrings separated by @a delimiters at the given @a startIndex onwards thru @a endIndex.\n"
    "@param text A @a delimiters list of substrings.\n"
    "@param delimiters Character or characters that separate the list of substrings in @a text.\n"
@@ -1736,7 +1736,7 @@ DefineConsoleFunction( getTokens, const char*, ( const char* text, const char* d
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( setToken, const char*, ( const char* text, const char* delimiters, S32 index, const char* replacement ),,
+DefineEngineFunction( setToken, const char*, ( const char* text, const char* delimiters, S32 index, const char* replacement ),,
    "Replace the substring in @a text separated by @a delimiters at the given @a index with @a replacement.\n"
    "@param text A @a delimiters list of substrings.\n"
    "@param delimiters Character or characters that separate the list of substrings in @a text.\n"
@@ -1758,7 +1758,7 @@ DefineConsoleFunction( setToken, const char*, ( const char* text, const char* de
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( removeToken, const char*, ( const char* text, const char* delimiters, S32 index ),,
+DefineEngineFunction( removeToken, const char*, ( const char* text, const char* delimiters, S32 index ),,
    "Remove the substring in @a text separated by @a delimiters at the given @a index.\n"
    "@param text A @a delimiters list of substrings.\n"
    "@param delimiters Character or characters that separate the list of substrings in @a text.\n"
@@ -1778,7 +1778,7 @@ DefineConsoleFunction( removeToken, const char*, ( const char* text, const char*
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getTokenCount, S32, ( const char* text, const char* delimiters),,
+DefineEngineFunction( getTokenCount, S32, ( const char* text, const char* delimiters),,
    "Return the number of @a delimiters substrings in @a text.\n"
    "@param text A @a delimiters list of substrings.\n"
    "@param delimiters Character or characters that separate the list of substrings in @a text.\n"
@@ -1837,7 +1837,7 @@ DefineEngineFunction( detag, const char*, ( const char* str ),,
       return str;
 }
 
-DefineConsoleFunction( getTag, const char*, ( const char* textTagString ), , "( string textTagString ) "
+DefineEngineFunction( getTag, const char*, ( const char* textTagString ), , "( string textTagString ) "
    "@brief Extracts the tag from a tagged string\n\n"
 
    "Should only be used within the context of a function that receives a tagged "
@@ -1968,7 +1968,7 @@ DefineEngineFunction( debugv, void, ( const char* variableName ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( expandEscape, const char*, ( const char* text ),,
+DefineEngineFunction( expandEscape, const char*, ( const char* text ),,
    "@brief Replace all characters in @a text that need to be escaped for the string to be a valid string literal with their "
    "respective escape sequences.\n\n"
    "All characters in @a text that cannot appear in a string literal will be replaced by an escape sequence (\\\\n, \\\\t, etc).\n\n"
@@ -1990,7 +1990,7 @@ DefineConsoleFunction( expandEscape, const char*, ( const char* text ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( collapseEscape, const char*, ( const char* text ),,
+DefineEngineFunction( collapseEscape, const char*, ( const char* text ),,
    "Replace all escape sequences in @a text with their respective character codes.\n\n"
    "This function replaces all escape sequences (\\\\n, \\\\t, etc) in the given string "
    "with the respective characters they represent.\n\n"
@@ -2046,7 +2046,7 @@ DefineEngineFunction( setLogMode, void, ( S32 mode ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( quit, void, ( ),,
+DefineEngineFunction( quit, void, ( ),,
    "Shut down the engine and exit its process.\n"
    "This function cleanly uninitializes the engine and then exits back to the system with a process "
    "exit status indicating a clean exit.\n\n"
@@ -2059,7 +2059,7 @@ DefineConsoleFunction( quit, void, ( ),,
 //-----------------------------------------------------------------------------
 
 
-DefineConsoleFunction( realQuit, void, (), , "")
+DefineEngineFunction( realQuit, void, (), , "")
 {
    Platform::postQuitMessage(0);
 }
@@ -2067,7 +2067,7 @@ DefineConsoleFunction( realQuit, void, (), , "")
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( quitWithErrorMessage, void, ( const char* message, S32 status ), (0),
+DefineEngineFunction( quitWithErrorMessage, void, ( const char* message, S32 status ), (0),
    "Display an error message box showing the given @a message and then shut down the engine and exit its process.\n"
    "This function cleanly uninitialized the engine and then exits back to the system with a process "
    "exit status indicating an error.\n\n"
@@ -2088,7 +2088,7 @@ DefineConsoleFunction( quitWithErrorMessage, void, ( const char* message, S32 st
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( quitWithStatus, void, ( S32 status ), (0),
+DefineEngineFunction( quitWithStatus, void, ( S32 status ), (0),
    "Shut down the engine and exit its process.\n"
    "This function cleanly uninitializes the engine and then exits back to the system with a given "
    "return status code.\n\n"
@@ -2259,7 +2259,7 @@ ConsoleFunction( call, const char *, 2, 0, "( string functionName, string args..
 static U32 execDepth = 0;
 static U32 journalDepth = 1;
 
-DefineConsoleFunction( getDSOPath, const char*, ( const char* scriptFileName ),,
+DefineEngineFunction( getDSOPath, const char*, ( const char* scriptFileName ),,
    "Get the absolute path to the file in which the compiled code for the given script file will be stored.\n"
    "@param scriptFileName %Path to the .cs script file.\n"
    "@return The absolute path to the .dso file for the given script file.\n\n"
@@ -2373,12 +2373,12 @@ DefineEngineFunction( exec, bool, ( const char* fileName, bool noCalls, bool jou
    return Con::executeFile(fileName, noCalls, journalScript);
 }
 
-DefineConsoleFunction( eval, const char*, ( const char* consoleString ), , "eval(consoleString)" )
+DefineEngineFunction( eval, const char*, ( const char* consoleString ), , "eval(consoleString)" )
 {
    return Con::evaluate(consoleString, false, NULL);
 }
 
-DefineConsoleFunction( getVariable, const char*, ( const char* varName ), , "(string varName)\n" 
+DefineEngineFunction( getVariable, const char*, ( const char* varName ), , "(string varName)\n" 
    "@brief Returns the value of the named variable or an empty string if not found.\n\n"
    "@varName Name of the variable to search for\n"
    "@return Value contained by varName, \"\" if the variable does not exist\n"
@@ -2387,7 +2387,7 @@ DefineConsoleFunction( getVariable, const char*, ( const char* varName ), , "(st
    return Con::getVariable(varName);
 }
 
-DefineConsoleFunction( setVariable, void, ( const char* varName, const char* value ), , "(string varName, string value)\n" 
+DefineEngineFunction( setVariable, void, ( const char* varName, const char* value ), , "(string varName, string value)\n" 
    "@brief Sets the value of the named variable.\n\n"
    "@param varName Name of the variable to locate\n"
    "@param value New value of the variable\n"
@@ -2397,7 +2397,7 @@ DefineConsoleFunction( setVariable, void, ( const char* varName, const char* val
    return Con::setVariable(varName, value);
 }
 
-DefineConsoleFunction( isFunction, bool, ( const char* funcName ), , "(string funcName)" 
+DefineEngineFunction( isFunction, bool, ( const char* funcName ), , "(string funcName)" 
    "@brief Determines if a function exists or not\n\n"
    "@param funcName String containing name of the function\n"
    "@return True if the function exists, false if not\n"
@@ -2406,7 +2406,7 @@ DefineConsoleFunction( isFunction, bool, ( const char* funcName ), , "(string fu
    return Con::isFunction(funcName);
 }
 
-DefineConsoleFunction( getFunctionPackage, const char*, ( const char* funcName ), , "(string funcName)" 
+DefineEngineFunction( getFunctionPackage, const char*, ( const char* funcName ), , "(string funcName)" 
    "@brief Provides the name of the package the function belongs to\n\n"
    "@param funcName String containing name of the function\n"
    "@return The name of the function's package\n"
@@ -2419,7 +2419,7 @@ DefineConsoleFunction( getFunctionPackage, const char*, ( const char* funcName )
    return nse->mPackage;
 }
 
-DefineConsoleFunction( isMethod, bool, ( const char* nameSpace, const char* method ), , "(string namespace, string method)" 
+DefineEngineFunction( isMethod, bool, ( const char* nameSpace, const char* method ), , "(string namespace, string method)" 
    "@brief Determines if a class/namespace method exists\n\n"
    "@param namespace Class or namespace, such as Player\n"
    "@param method Name of the function to search for\n"
@@ -2434,7 +2434,7 @@ DefineConsoleFunction( isMethod, bool, ( const char* nameSpace, const char* meth
    return true;
 }
 
-DefineConsoleFunction( getMethodPackage, const char*, ( const char* nameSpace, const char* method ), , "(string namespace, string method)" 
+DefineEngineFunction( getMethodPackage, const char*, ( const char* nameSpace, const char* method ), , "(string namespace, string method)" 
    "@brief Provides the name of the package the method belongs to\n\n"
    "@param namespace Class or namespace, such as Player\n"
    "@param method Name of the funciton to search for\n"
@@ -2452,7 +2452,7 @@ DefineConsoleFunction( getMethodPackage, const char*, ( const char* nameSpace, c
    return nse->mPackage;
 }
 
-DefineConsoleFunction( isDefined, bool, ( const char* varName, const char* varValue ), ("") , "(string varName)" 
+DefineEngineFunction( isDefined, bool, ( const char* varName, const char* varValue ), ("") , "(string varName)" 
    "@brief Determines if a variable exists and contains a value\n"
    "@param varName Name of the variable to search for\n"
    "@return True if the variable was defined in script, false if not\n"
@@ -2590,14 +2590,14 @@ DefineConsoleFunction( isDefined, bool, ( const char* varName, const char* varVa
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( isCurrentScriptToolScript, bool, (), , "()" 
+DefineEngineFunction( isCurrentScriptToolScript, bool, (), , "()" 
    "Returns true if the calling script is a tools script.\n"
    "@hide")
 {
    return Con::isCurrentScriptToolScript();
 }
 
-DefineConsoleFunction( getModNameFromPath, const char *, ( const char* path ), , "(string path)" 
+DefineEngineFunction( getModNameFromPath, const char *, ( const char* path ), , "(string path)" 
             "@brief Attempts to extract a mod directory from path. Returns empty string on failure.\n\n"
             "@param File path of mod folder\n"
             "@note This is no longer relevant in Torque 3D (which does not use mod folders), should be deprecated\n"
@@ -2609,7 +2609,7 @@ DefineConsoleFunction( getModNameFromPath, const char *, ( const char* path ), ,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( pushInstantGroup, void, ( String group ),("") , "([group])" 
+DefineEngineFunction( pushInstantGroup, void, ( String group ),("") , "([group])" 
             "@brief Pushes the current $instantGroup on a stack "
             "and sets it to the given value (or clears it).\n\n"
             "@note Currently only used for editors\n"
@@ -2622,7 +2622,7 @@ DefineConsoleFunction( pushInstantGroup, void, ( String group ),("") , "([group]
       Con::pushInstantGroup();
 }
 
-DefineConsoleFunction( popInstantGroup, void, (), , "()" 
+DefineEngineFunction( popInstantGroup, void, (), , "()" 
             "@brief Pop and restore the last setting of $instantGroup off the stack.\n\n"
             "@note Currently only used for editors\n\n"
             "@ingroup Editors\n"
@@ -2633,7 +2633,7 @@ DefineConsoleFunction( popInstantGroup, void, (), , "()"
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getPrefsPath, const char *, ( const char* relativeFileName ), (""), "([relativeFileName])" 
+DefineEngineFunction( getPrefsPath, const char *, ( const char* relativeFileName ), (""), "([relativeFileName])" 
             "@note Appears to be useless in Torque 3D, should be deprecated\n"
             "@internal")
 {
@@ -2670,7 +2670,7 @@ ConsoleFunction( execPrefs, bool, 2, 4, "( string relativeFileName, bool noCalls
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( export, void, ( const char* pattern, const char* filename, bool append ), ( "", false ),
+DefineEngineFunction( export, void, ( const char* pattern, const char* filename, bool append ), ( "", false ),
    "Write out the definitions of all global variables matching the given name @a pattern.\n"
    "If @a fileName is not \"\", the variable definitions are written to the specified file.  Otherwise the "
    "definitions will be printed to the console.\n\n"
@@ -2723,7 +2723,7 @@ DefineEngineFunction( deleteVariables, void, ( const char* pattern ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( trace, void, ( bool enable ), ( true ),
+DefineEngineFunction( trace, void, ( bool enable ), ( true ),
    "Enable or disable tracing in the script code VM.\n\n"
    "When enabled, the script code runtime will trace the invocation and returns "
    "from all functions that are called and log them to the console. This is helpful in "
@@ -2739,7 +2739,7 @@ DefineConsoleFunction( trace, void, ( bool enable ), ( true ),
 
 #if defined(TORQUE_DEBUG) || !defined(TORQUE_SHIPPING)
 
-DefineConsoleFunction( debug, void, (),,
+DefineEngineFunction( debug, void, (),,
    "Drops the engine into the native C++ debugger.\n\n"
    "This function triggers a debug break and drops the process into the IDE's debugger.  If the process is not "
    "running with a debugger attached it will generate a runtime error on most platforms.\n\n"

Engine/source/console/consoleXMLExport.cpp

@@ -314,7 +314,7 @@ namespace Con {
 }; // namespace Con
 
 
-DefineConsoleFunction( consoleExportXML, const char*, (), ,"Exports console definition XML representation" )
+DefineEngineFunction( consoleExportXML, const char*, (), ,"Exports console definition XML representation" )
 {
    Con::XMLExport xmlExport;
    String xml;

Engine/source/console/engineAPI.h

@@ -860,24 +860,6 @@ public:
 // while being only visible in the console interop.  When we drop the console system,
 // these macros can be removed and all definitions that make use of them can be removed
 // as well.
-#define DefineConsoleFunction( name, returnType, args, defaultArgs, usage )                                                      \
-   static inline returnType _fn ## name ## impl args;                                                                            \
-   static _EngineFunctionDefaultArguments< void args > _fn ## name ## DefaultArgs defaultArgs;                                   \
-   static _EngineConsoleThunkType< returnType >::ReturnType _ ## name ## caster( SimObject*, S32 argc, ConsoleValueRef *argv )       \
-   {                                                                                                                             \
-      return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 1, returnType args >::thunk(                \
-         argc, argv, &_fn ## name ## impl, _fn ## name ## DefaultArgs                                                            \
-      ) );                                                                                                                       \
-   }                                                                                                                             \
-   static ConsoleFunctionHeader _ ## name ## header                                                                              \
-      ( #returnType, #args, #defaultArgs );                                                                                      \
-   static ConsoleConstructor                                                                                                     \
-      _ ## name ## obj( NULL, #name, _EngineConsoleThunkType< returnType >::CallbackType( _ ## name ## caster ), usage,          \
-         _EngineConsoleThunk< 1, returnType args >::NUM_ARGS - _EngineConsoleThunkCountArgs() defaultArgs,                       \
-         _EngineConsoleThunk< 1, returnType args >::NUM_ARGS,                                                                    \
-         false, &_ ## name ## header                                                                                             \
-      );                                                                                                                         \
-   static inline returnType _fn ## name ## impl args
 
 #define DefineConsoleMethod( className, name, returnType, args, defaultArgs, usage )                                                            \
    struct _ ## className ## name ## frame                                                                                                       \

Engine/source/console/sim.cpp

@@ -86,7 +86,7 @@ namespace Sim
 
 ConsoleFunctionGroupBegin ( SimFunctions, "Functions relating to Sim.");
 
-DefineConsoleFunction( nameToID, S32, (const char * objectName), ,"nameToID(object)")
+DefineEngineFunction( nameToID, S32, (const char * objectName), ,"nameToID(object)")
 {
    SimObject *obj = Sim::findObject(objectName);
    if(obj)
@@ -95,7 +95,7 @@ DefineConsoleFunction( nameToID, S32, (const char * objectName), ,"nameToID(obje
       return -1;
 }
 
-DefineConsoleFunction( isObject, bool, (const char * objectName), ,"isObject(object)")
+DefineEngineFunction( isObject, bool, (const char * objectName), ,"isObject(object)")
 {
    if (!dStrcmp(objectName, "0") || !dStrcmp(objectName, ""))
       return false;
@@ -133,7 +133,7 @@ ConsoleDocFragment _spawnObject1(
    "bool spawnObject(class [, dataBlock, name, properties, script]);"
 );
 
-DefineConsoleFunction( spawnObject, S32, (   const char * spawnClass
+DefineEngineFunction( spawnObject, S32, (   const char * spawnClass
                                          ,   const char * spawnDataBlock
                                          ,   const char * spawnName
                                          ,   const char * spawnProperties
@@ -149,33 +149,33 @@ DefineConsoleFunction( spawnObject, S32, (   const char * spawnClass
       return -1;
 }
 
-DefineConsoleFunction( cancel, void, (S32 eventId), ,"cancel(eventId)")
+DefineEngineFunction( cancel, void, (S32 eventId), ,"cancel(eventId)")
 {
    Sim::cancelEvent(eventId);
 }
 
-DefineConsoleFunction( cancelAll, void, (const char * objectId), ,"cancelAll(objectId): cancel pending events on the specified object.  Events will be automatically cancelled if object is deleted.")
+DefineEngineFunction( cancelAll, void, (const char * objectId), ,"cancelAll(objectId): cancel pending events on the specified object.  Events will be automatically cancelled if object is deleted.")
 {
    Sim::cancelPendingEvents(Sim::findObject(objectId));
 }
 
-DefineConsoleFunction( isEventPending, bool, (S32 scheduleId), ,"isEventPending(%scheduleId);")
+DefineEngineFunction( isEventPending, bool, (S32 scheduleId), ,"isEventPending(%scheduleId);")
 {
    return Sim::isEventPending(scheduleId);
 }
 
-DefineConsoleFunction( getEventTimeLeft, S32, (S32 scheduleId), ,"getEventTimeLeft(scheduleId) Get the time left in ms until this event will trigger.")
+DefineEngineFunction( getEventTimeLeft, S32, (S32 scheduleId), ,"getEventTimeLeft(scheduleId) Get the time left in ms until this event will trigger.")
 {
    return Sim::getEventTimeLeft(scheduleId);
 }
 
-DefineConsoleFunction( getScheduleDuration, S32, (S32 scheduleId), ,"getScheduleDuration(%scheduleId);" )
+DefineEngineFunction( getScheduleDuration, S32, (S32 scheduleId), ,"getScheduleDuration(%scheduleId);" )
 {
    S32 ret = Sim::getScheduleDuration(scheduleId);
    return ret;
 }
 
-DefineConsoleFunction( getTimeSinceStart, S32, (S32 scheduleId), ,"getTimeSinceStart(%scheduleId);" )
+DefineEngineFunction( getTimeSinceStart, S32, (S32 scheduleId), ,"getTimeSinceStart(%scheduleId);" )
 {
    S32 ret = Sim::getTimeSinceStart(scheduleId);
    return ret;
@@ -202,7 +202,7 @@ ConsoleFunction(schedule, S32, 4, 0, "schedule(time, refobject|0, command, <arg1
    return ret;
 }
 
-DefineConsoleFunction( getUniqueName, const char*, (const char * baseName), ,
+DefineEngineFunction( getUniqueName, const char*, (const char * baseName), ,
    "( String baseName )\n"
    "@brief Returns a unique unused SimObject name based on a given base name.\n\n"
    "@baseName Name to conver to a unique string if another instance exists\n"
@@ -221,7 +221,7 @@ DefineConsoleFunction( getUniqueName, const char*, (const char * baseName), ,
    return buffer;
 }
 
-DefineConsoleFunction( getUniqueInternalName, const char*, (const char * baseName, const char * setString, bool searchChildren), ,
+DefineEngineFunction( getUniqueInternalName, const char*, (const char * baseName, const char * setString, bool searchChildren), ,
    "( String baseName, SimSet set, bool searchChildren )\n"
    "@brief Returns a unique unused internal name within the SimSet/Group based on a given base name.\n\n"
    "@note Currently only used by editors\n"
@@ -246,7 +246,7 @@ DefineConsoleFunction( getUniqueInternalName, const char*, (const char * baseNam
    return buffer;
 }
 
-DefineConsoleFunction( isValidObjectName, bool, (const char * name), , "( string name )"
+DefineEngineFunction( isValidObjectName, bool, (const char * name), , "( string name )"
             "@brief Return true if the given name makes for a valid object name.\n\n"
             "@param name Name of object\n"
             "@return True if name is allowed, false if denied (usually because it starts with a number, _, or invalid character"

Engine/source/console/simDatablock.cpp

@@ -464,7 +464,7 @@ DefineConsoleMethod( SimDataBlock, reloadOnLocalClient, void, (),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( preloadClientDataBlocks, void, (),,
+DefineEngineFunction( preloadClientDataBlocks, void, (),,
    "Preload all datablocks in client mode.\n\n"
    "(Server parameter is set to false).  This will take some time to complete.")
 {
@@ -482,7 +482,7 @@ DefineConsoleFunction( preloadClientDataBlocks, void, (),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( deleteDataBlocks, void, (),,
+DefineEngineFunction( deleteDataBlocks, void, (),,
    "Delete all the datablocks we've downloaded.\n\n"
    "This is usually done in preparation of downloading a new set of datablocks, "
    "such as occurs on a mission change, but it's also good post-mission cleanup." )

Engine/source/console/telnetConsole.cpp

@@ -61,7 +61,7 @@ void TelnetConsole::destroy()
    TelConsole = NULL;
 }
 
-DefineConsoleFunction( telnetSetParameters, void, ( int port, const char* consolePass, const char* listenPass, bool remoteEcho ), ( false ),
+DefineEngineFunction( telnetSetParameters, void, ( int port, const char* consolePass, const char* listenPass, bool remoteEcho ), ( false ),
                 "@brief Initializes and open the telnet console.\n\n"
                 "@param port        Port to listen on for console connections (0 will shut down listening).\n"
                 "@param consolePass Password for read/write access to console.\n"

Engine/source/console/telnetDebugger.cpp

@@ -113,7 +113,7 @@ MODULE_END;
 // BRKCLR file line - sent when a breakpoint cannot be moved to a breakable line on the client.
 //
 
-DefineConsoleFunction( dbgSetParameters, void, (S32 port, const char * password, bool waitForClient ), (false), "( int port, string password, bool waitForClient )"
+DefineEngineFunction( dbgSetParameters, void, (S32 port, const char * password, bool waitForClient ), (false), "( int port, string password, bool waitForClient )"
                 "Open a debug server port on the specified port, requiring the specified password, "
             "and optionally waiting for the debug client to connect.\n"
             "@internal Primarily used for Torsion and other debugging tools")
@@ -124,14 +124,14 @@ DefineConsoleFunction( dbgSetParameters, void, (S32 port, const char * password,
    }
 }
 
-DefineConsoleFunction( dbgIsConnected, bool, (), , "()"
+DefineEngineFunction( dbgIsConnected, bool, (), , "()"
                 "Returns true if a script debugging client is connected else return false.\n"
             "@internal Primarily used for Torsion and other debugging tools")
 {
    return TelDebugger && TelDebugger->isConnected();
 }
 
-DefineConsoleFunction( dbgDisconnect, void, (), , "()"
+DefineEngineFunction( dbgDisconnect, void, (), , "()"
                 "Forcibly disconnects any attached script debugging client.\n"
             "@internal Primarily used for Torsion and other debugging tools")
 {

Engine/source/core/dnet.cpp

@@ -50,7 +50,7 @@ static const char *packetTypeNames[] =
 //-----------------------------------------------------------------
 //-----------------------------------------------------------------
 //-----------------------------------------------------------------
-DefineConsoleFunction( DNetSetLogging, void, (bool enabled), , "(bool enabled)"
+DefineEngineFunction( DNetSetLogging, void, (bool enabled), , "(bool enabled)"
    "@brief Enables logging of the connection protocols\n\n"
    "When enabled a lot of network debugging information is sent to the console.\n"
    "@param enabled True to enable, false to disable\n"

Engine/source/core/stringBuffer.cpp

@@ -48,12 +48,12 @@
          void dumpAllStrings();
    };
 
-   DefineConsoleFunction( sbmDumpStats, void, (), , "()")
+   DefineEngineFunction( sbmDumpStats, void, (), , "()")
    {
       StringBufferManager::getManager().dumpStats();
    }
 
-   DefineConsoleFunction( sbmDumpStrings, void, (), , "()")
+   DefineEngineFunction( sbmDumpStrings, void, (), , "()")
    {
       StringBufferManager::getManager().dumpAllStrings();
    }

Engine/source/core/util/str.cpp

@@ -480,7 +480,7 @@ static U32 sgStringInstances;
 
 
 #endif
-DefineConsoleFunction( dumpStringMemStats, void, (), , "()"
+DefineEngineFunction( dumpStringMemStats, void, (), , "()"
 				"@brief Dumps information about String memory usage\n\n"
 				"@ingroup Debugging\n"
 				"@ingroup Strings\n")

Engine/source/environment/VolumetricFogRTManager.cpp

@@ -283,7 +283,7 @@ VolumetricFogRTManager* VolumetricFogRTManager::get()
    return gVolumetricFogRTManager;
 }
    
-DefineConsoleFunction(SetFogVolumeQuality, S32, (U32 new_quality), ,
+DefineEngineFunction(SetFogVolumeQuality, S32, (U32 new_quality), ,
 "@brief Resizes the rendertargets of the Volumetric Fog object.\n"
 "@params new_quality new quality for the rendertargets 1 = full size, 2 = halfsize, 3 = 1/3, 4 = 1/4 ...")
 {

Engine/source/gfx/gfxDevice.cpp

@@ -1333,7 +1333,7 @@ DefineEngineFunction( getBestHDRFormat, GFXFormat, (),,
    return format;
 }
 
-DefineConsoleFunction(ResetGFX, void, (), , "forces the gbuffer to be reinitialized in cases of improper/lack of buffer clears.")
+DefineEngineFunction(ResetGFX, void, (), , "forces the gbuffer to be reinitialized in cases of improper/lack of buffer clears.")
 {
    GFX->beginReset();
 }

Engine/source/gfx/gl/gfxGLDeviceProfiler.cpp

@@ -86,7 +86,7 @@ protected:
 
 GFXProfiler<GLTimer> gfxProfiler;
 
-DefineConsoleFunction(printGFXGLTimers, void,(), ,"")
+DefineEngineFunction(printGFXGLTimers, void,(), ,"")
 {
    gfxProfiler.printTimes();
 }

Engine/source/i18n/i18n.cpp

@@ -58,7 +58,7 @@ const UTF8 *getCoreString(S32 id)
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getCoreLangTable, S32, (), , "()"
+DefineEngineFunction( getCoreLangTable, S32, (), , "()"
 				"@brief Gets the primary LangTable used by the game\n\n"
 				"@return ID of the core LangTable\n"
 				"@ingroup Localization")
@@ -69,7 +69,7 @@ DefineConsoleFunction( getCoreLangTable, S32, (), , "()"
       return 0;
 }
 
-DefineConsoleFunction( setCoreLangTable, void, (const char * lgTable), , "(string LangTable)"
+DefineEngineFunction( setCoreLangTable, void, (const char * lgTable), , "(string LangTable)"
 				"@brief Sets the primary LangTable used by the game\n\n"
 				"@param LangTable ID of the core LangTable\n"
 				"@ingroup Localization")

Engine/source/lighting/advanced/advancedLightManager.cpp

@@ -705,7 +705,7 @@ LightShadowMap* AdvancedLightManager::findShadowMapForObject( SimObject *object
    return sceneLight->getLight()->getExtended<ShadowMapParams>()->getShadowMap();
 }
 
-DefineConsoleFunction( setShadowVizLight, const char*, (const char* name), (""), "")
+DefineEngineFunction( setShadowVizLight, const char*, (const char* name), (""), "")
 {
    static const String DebugTargetName( "AL_ShadowVizTexture" );
 

Engine/source/lighting/shadowManager.cpp

@@ -54,7 +54,7 @@ SceneManager* ShadowManager::getSceneManager()
 //------------------------------------------------------------------------------
 
 // Runtime switching of shadow systems.  Requires correct world to be pushed at console.
-DefineConsoleFunction( setShadowManager, bool, (const char* sShadowSystemName), (""), "string sShadowSystemName")
+DefineEngineFunction( setShadowManager, bool, (const char* sShadowSystemName), (""), "string sShadowSystemName")
 {
    /*
    // Make sure this new one exists

Engine/source/materials/materialManager.cpp

@@ -454,14 +454,14 @@ bool MaterialManager::_handleGFXEvent( GFXDevice::GFXDeviceEventType event_ )
    return true;
 }
 
-DefineConsoleFunction( reInitMaterials, void, (),,
+DefineEngineFunction( reInitMaterials, void, (),,
    "@brief Flushes all procedural shaders and re-initializes all active material instances.\n\n" 
    "@ingroup Materials")
 {
    MATMGR->flushAndReInitInstances();
 }
 
-DefineConsoleFunction( addMaterialMapping, void, (const char * texName, const char * matName), , "(string texName, string matName)\n"
+DefineEngineFunction( addMaterialMapping, void, (const char * texName, const char * matName), , "(string texName, string matName)\n"
    "@brief Maps the given texture to the given material.\n\n"
    "Generates a console warning before overwriting.\n\n"
    "Material maps are used by terrain and interiors for triggering "
@@ -472,7 +472,7 @@ DefineConsoleFunction( addMaterialMapping, void, (const char * texName, const ch
    MATMGR->mapMaterial(texName, matName);
 }
 
-DefineConsoleFunction( getMaterialMapping, const char*, (const char * texName), , "(string texName)\n"
+DefineEngineFunction( getMaterialMapping, const char*, (const char * texName), , "(string texName)\n"
    "@brief Returns the name of the material mapped to this texture.\n\n"
    "If no materials are found, an empty string is returned.\n\n"
    "@param texName Name of the texture\n\n"
@@ -481,14 +481,14 @@ DefineConsoleFunction( getMaterialMapping, const char*, (const char * texName),
    return MATMGR->getMapEntry(texName).c_str();
 }
 
-DefineConsoleFunction( dumpMaterialInstances, void, (), ,
+DefineEngineFunction( dumpMaterialInstances, void, (), ,
    "@brief Dumps a formatted list of currently allocated material instances to the console.\n\n"
    "@ingroup Materials")
 {
    MATMGR->dumpMaterialInstances();
 }
 
-DefineConsoleFunction( getMapEntry, const char*, (const char * texName), ,
+DefineEngineFunction( getMapEntry, const char*, (const char * texName), ,
    "@hide")
 {
 	return MATMGR->getMapEntry( String(texName) );

Engine/source/math/mConsoleFunctions.cpp

@@ -31,7 +31,7 @@
 #include "console/engineAPI.h"
 
 
-DefineConsoleFunction( mSolveQuadratic, const char*, ( F32 a, F32 b, F32 c ),,
+DefineEngineFunction( mSolveQuadratic, const char*, ( F32 a, F32 b, F32 c ),,
     "Solve a quadratic equation (2nd degree polynomial) of form a*x^2 + b*x + c = 0.\n"
     "@param a First Coefficient."
     "@param b Second Coefficient."
@@ -49,7 +49,7 @@ DefineConsoleFunction( mSolveQuadratic, const char*, ( F32 a, F32 b, F32 c ),,
    return retBuffer;
 }
 
-DefineConsoleFunction( mSolveCubic, const char*, ( F32 a, F32 b, F32 c, F32 d ),,
+DefineEngineFunction( mSolveCubic, const char*, ( F32 a, F32 b, F32 c, F32 d ),,
     "Solve a cubic equation (3rd degree polynomial) of form a*x^3 + b*x^2 + c*x + d = 0.\n"
     "@param a First Coefficient."
     "@param b Second Coefficient."
@@ -68,7 +68,7 @@ DefineConsoleFunction( mSolveCubic, const char*, ( F32 a, F32 b, F32 c, F32 d ),
    return retBuffer;
 }
 
-DefineConsoleFunction( mSolveQuartic, const char*, ( F32 a, F32 b, F32 c, F32 d, F32 e ),,
+DefineEngineFunction( mSolveQuartic, const char*, ( F32 a, F32 b, F32 c, F32 d, F32 e ),,
     "Solve a quartic equation (4th degree polynomial) of form a*x^4 + b*x^3 + c*x^2 + d*x + e = 0.\n"
     "@param a First Coefficient."
     "@param b Second Coefficient."
@@ -87,7 +87,7 @@ DefineConsoleFunction( mSolveQuartic, const char*, ( F32 a, F32 b, F32 c, F32 d,
    return retBuffer;
 }
 
-DefineConsoleFunction( mFloor, S32, ( F32 v ),,
+DefineEngineFunction( mFloor, S32, ( F32 v ),,
     "Round v down to the nearest integer.\n"
     "@param v Number to convert to integer."
     "@returns Number converted to integer."
@@ -96,7 +96,7 @@ DefineConsoleFunction( mFloor, S32, ( F32 v ),,
    return (S32)mFloor( v );
 }
 
-DefineConsoleFunction( mRound, S32, ( F32 v  ),,
+DefineEngineFunction( mRound, S32, ( F32 v  ),,
     "Round v to the nth decimal place or the nearest whole number by default."
     "@param v Value to roundn"
     "@return The rounded value as a S32."  
@@ -105,7 +105,7 @@ DefineConsoleFunction( mRound, S32, ( F32 v  ),,
    return mRound(v);
 }
 
-DefineConsoleFunction( mRoundColour, F32, ( F32 v, S32 n ), (0),
+DefineEngineFunction( mRoundColour, F32, ( F32 v, S32 n ), (0),
    "Round v to the nth decimal place or the nearest whole number by default."
    "@param v Value to roundn"
    "@param n Number of decimal places to round to, 0 by defaultn"
@@ -118,7 +118,7 @@ DefineConsoleFunction( mRoundColour, F32, ( F32 v, S32 n ), (0),
       return mRound(v, n);
 }
 
-DefineConsoleFunction( mCeil, S32, ( F32 v ),,
+DefineEngineFunction( mCeil, S32, ( F32 v ),,
     "Round v up to the nearest integer.\n"
     "@param v Number to convert to integer."
     "@returns Number converted to integer."
@@ -127,7 +127,7 @@ DefineConsoleFunction( mCeil, S32, ( F32 v ),,
    return (S32)mCeil( v );
 }
 
-DefineConsoleFunction( mFloatLength, const char*, ( F32 v, U32 precision ),,
+DefineEngineFunction( mFloatLength, const char*, ( F32 v, U32 precision ),,
     "Formats the specified number to the given number of decimal places.\n"
     "@param v Number to format."
     "@param precision Number of decimal places to format to (1-9)."
@@ -148,7 +148,7 @@ DefineConsoleFunction( mFloatLength, const char*, ( F32 v, U32 precision ),,
 
 //------------------------------------------------------------------------------
 
-DefineConsoleFunction( mAbs, F32, ( F32 v ),,
+DefineEngineFunction( mAbs, F32, ( F32 v ),,
     "Calculate absolute value of specified value.\n"
     "@param v Input Value."
     "@returns Absolute value of specified value."
@@ -157,7 +157,7 @@ DefineConsoleFunction( mAbs, F32, ( F32 v ),,
    return mFabs( v );
 }
 
-DefineConsoleFunction( mFMod, F32, ( F32 v, F32 d ),,
+DefineEngineFunction( mFMod, F32, ( F32 v, F32 d ),,
     "Calculate the remainder of v/d.\n"
     "@param v Input Value."
     "@param d Divisor Value."
@@ -167,7 +167,7 @@ DefineConsoleFunction( mFMod, F32, ( F32 v, F32 d ),,
    return mFmod( v, d );
 }
 
-DefineConsoleFunction( mSqrt, F32, ( F32 v ),,
+DefineEngineFunction( mSqrt, F32, ( F32 v ),,
     "Calculate the square-root of v.\n"
     "@param v Input Value."
     "@returns The square-root of the input value."
@@ -176,7 +176,7 @@ DefineConsoleFunction( mSqrt, F32, ( F32 v ),,
    return mSqrt (v );
 }
 
-DefineConsoleFunction( mPow, F32, ( F32 v, F32 p ),,
+DefineEngineFunction( mPow, F32, ( F32 v, F32 p ),,
     "Calculate b raised to the p-th power.\n"
     "@param v Input Value."
     "@param p Power to raise value by."
@@ -186,7 +186,7 @@ DefineConsoleFunction( mPow, F32, ( F32 v, F32 p ),,
    return mPow( v, p );
 }
 
-DefineConsoleFunction( mLog, F32, ( F32 v ),,
+DefineEngineFunction( mLog, F32, ( F32 v ),,
     "Calculate the natural logarithm of v.\n"
     "@param v Input Value."
     "@returns The natural logarithm of the input value."
@@ -195,7 +195,7 @@ DefineConsoleFunction( mLog, F32, ( F32 v ),,
    return mLog( v );
 }
 
-DefineConsoleFunction( mSin, F32, ( F32 v ),,
+DefineEngineFunction( mSin, F32, ( F32 v ),,
     "Calculate the sine of v.\n"
     "@param v Input Value (in radians)."
     "@returns The sine of the input value."
@@ -204,7 +204,7 @@ DefineConsoleFunction( mSin, F32, ( F32 v ),,
    return mSin( v );
 }
 
-DefineConsoleFunction( mCos, F32, ( F32 v ),,
+DefineEngineFunction( mCos, F32, ( F32 v ),,
     "Calculate the cosine of v.\n"
     "@param v Input Value (in radians)."
     "@returns The cosine of the input value."
@@ -213,7 +213,7 @@ DefineConsoleFunction( mCos, F32, ( F32 v ),,
    return mCos( v );
 }
 
-DefineConsoleFunction( mTan, F32, ( F32 v ),,
+DefineEngineFunction( mTan, F32, ( F32 v ),,
     "Calculate the tangent of v.\n"
     "@param v Input Value (in radians)."
     "@returns The tangent of the input value."
@@ -222,7 +222,7 @@ DefineConsoleFunction( mTan, F32, ( F32 v ),,
    return mTan( v );
 }
 
-DefineConsoleFunction( mAsin, F32, ( F32 v ),,
+DefineEngineFunction( mAsin, F32, ( F32 v ),,
     "Calculate the arc-sine of v.\n"
     "@param v Input Value (in radians)."
     "@returns The arc-sine of the input value."
@@ -231,7 +231,7 @@ DefineConsoleFunction( mAsin, F32, ( F32 v ),,
    return mAsin( v );
 }
 
-DefineConsoleFunction( mAcos, F32, ( F32 v ),,
+DefineEngineFunction( mAcos, F32, ( F32 v ),,
     "Calculate the arc-cosine of v.\n"
     "@param v Input Value (in radians)."
     "@returns The arc-cosine of the input value."
@@ -240,7 +240,7 @@ DefineConsoleFunction( mAcos, F32, ( F32 v ),,
    return mAcos( v );
 }
 
-DefineConsoleFunction( mAtan, F32, ( F32 rise, F32 run ),,
+DefineEngineFunction( mAtan, F32, ( F32 rise, F32 run ),,
     "Calculate the arc-tangent (slope) of a line defined by rise and run.\n"
     "@param rise of line."
     "@param run of line."
@@ -250,7 +250,7 @@ DefineConsoleFunction( mAtan, F32, ( F32 rise, F32 run ),,
    return mAtan2( rise, run );
 }
 
-DefineConsoleFunction( mRadToDeg, F32, ( F32 radians ),,
+DefineEngineFunction( mRadToDeg, F32, ( F32 radians ),,
     "Convert specified radians into degrees.\n"
     "@param radians Input Value (in radians)."
     "@returns The specified radians value converted to degrees."
@@ -259,7 +259,7 @@ DefineConsoleFunction( mRadToDeg, F32, ( F32 radians ),,
    return mRadToDeg( radians );
 }
 
-DefineConsoleFunction( mDegToRad, F32, ( F32 degrees ),,
+DefineEngineFunction( mDegToRad, F32, ( F32 degrees ),,
     "Convert specified degrees into radians.\n"
     "@param degrees Input Value (in degrees)."
     "@returns The specified degrees value converted to radians."
@@ -268,7 +268,7 @@ DefineConsoleFunction( mDegToRad, F32, ( F32 degrees ),,
    return mDegToRad( degrees );
 }
 
-DefineConsoleFunction( mClamp, F32, ( F32 v, F32 min, F32 max ),,
+DefineEngineFunction( mClamp, F32, ( F32 v, F32 min, F32 max ),,
     "Clamp the specified value between two bounds.\n"
     "@param v Input value."
     "@param min Minimum Bound."
@@ -279,7 +279,7 @@ DefineConsoleFunction( mClamp, F32, ( F32 v, F32 min, F32 max ),,
    return mClampF( v, min, max );
 }
 
-DefineConsoleFunction( mSaturate, F32, ( F32 v ),,
+DefineEngineFunction( mSaturate, F32, ( F32 v ),,
     "Clamp the specified value between 0 and 1 (inclusive).\n"
     "@param v Input value."
     "@returns The specified value clamped between 0 and 1 (inclusive)."
@@ -288,7 +288,7 @@ DefineConsoleFunction( mSaturate, F32, ( F32 v ),,
    return mClampF( v, 0.0f, 1.0f );
 }
 
-DefineConsoleFunction(mWrapF, F32, (F32 v, F32 min, F32 max), ,
+DefineEngineFunction(mWrapF, F32, (F32 v, F32 min, F32 max), ,
 	"Wrap the specified value between two bounds.\n"
 	"@param v Input value."
 	"@param min Minimum Bound."
@@ -299,7 +299,7 @@ DefineConsoleFunction(mWrapF, F32, (F32 v, F32 min, F32 max), ,
 	return mWrapF(v, min, max);
 }
 
-DefineConsoleFunction(mWrap, S32, (S32 v, S32 min, S32 max), ,
+DefineEngineFunction(mWrap, S32, (S32 v, S32 min, S32 max), ,
 	"Wrap the specified value between two bounds.\n"
 	"@param v Input value."
 	"@param min Minimum Bound."
@@ -311,7 +311,7 @@ DefineConsoleFunction(mWrap, S32, (S32 v, S32 min, S32 max), ,
 }
 
 
-DefineConsoleFunction( getMax, F32, ( F32 v1, F32 v2 ),,
+DefineEngineFunction( getMax, F32, ( F32 v1, F32 v2 ),,
     "Calculate the greater of two specified numbers.\n"
     "@param v1 Input value."
     "@param v2 Input value."
@@ -321,7 +321,7 @@ DefineConsoleFunction( getMax, F32, ( F32 v1, F32 v2 ),,
    return getMax( v1, v2 );
 }
 
-DefineConsoleFunction( getMin, F32, ( F32 v1, F32 v2 ),,
+DefineEngineFunction( getMin, F32, ( F32 v1, F32 v2 ),,
     "Calculate the lesser of two specified numbers.\n"
     "@param v1 Input value."
     "@param v2 Input value."
@@ -331,7 +331,7 @@ DefineConsoleFunction( getMin, F32, ( F32 v1, F32 v2 ),,
    return getMin( v1, v2 );
 }
 
-DefineConsoleFunction( mLerp, F32, ( F32 v1, F32 v2, F32 time ),,
+DefineEngineFunction( mLerp, F32, ( F32 v1, F32 v2, F32 time ),,
     "Calculate linearly interpolated value between two specified numbers using specified normalized time.\n"
     "@param v1 Interpolate From Input value."
     "@param v2 Interpolate To Input value."
@@ -342,7 +342,7 @@ DefineConsoleFunction( mLerp, F32, ( F32 v1, F32 v2, F32 time ),,
    return mLerp( v1, v2, time );
 }
 
-DefineConsoleFunction( mPi, F32, (),,
+DefineEngineFunction( mPi, F32, (),,
     "Return the value of PI (half-circle in radians).\n"
     "@returns The value of PI."
     "@ingroup Math" )
@@ -350,7 +350,7 @@ DefineConsoleFunction( mPi, F32, (),,
    return M_PI_F;
 }
 
-DefineConsoleFunction( m2Pi, F32, (),,
+DefineEngineFunction( m2Pi, F32, (),,
     "Return the value of 2*PI (full-circle in radians).\n"
     "@returns The value of 2*PI."
     "@ingroup Math" )
@@ -358,7 +358,7 @@ DefineConsoleFunction( m2Pi, F32, (),,
    return M_2PI_F;
 }
 
-DefineConsoleFunction( mIsPow2, bool, ( S32 v ),,
+DefineEngineFunction( mIsPow2, bool, ( S32 v ),,
     "Returns whether the value is an exact power of two.\n"
     "@param v Input value."
     "@returns Whether the specified value is an exact power of two."
@@ -367,7 +367,7 @@ DefineConsoleFunction( mIsPow2, bool, ( S32 v ),,
    return isPow2( v );
 }
 
-DefineConsoleFunction( mRandomDir, Point3F, (Point3F axis, F32 angleMin, F32 angleMax),,
+DefineEngineFunction( mRandomDir, Point3F, (Point3F axis, F32 angleMin, F32 angleMax),,
    "Returns a randomized direction based on a starting axis and the min/max angles.\n"
    "@param axis Main axis to deviate the direction from."
    "@param angleMin minimum amount of deviation from the axis."
@@ -378,7 +378,7 @@ DefineConsoleFunction( mRandomDir, Point3F, (Point3F axis, F32 angleMin, F32 ang
    return MathUtils::randomDir(axis, angleMin, angleMax);
 }
 
-DefineConsoleFunction( mRandomPointInSphere, Point3F, (F32 radius), ,
+DefineEngineFunction( mRandomPointInSphere, Point3F, (F32 radius), ,
    "Returns a randomized point inside a sphere of a given radius.\n"
    "@param radius The radius of the sphere to find a point in."
    "@returns Randomized point inside a sphere."
@@ -387,7 +387,7 @@ DefineConsoleFunction( mRandomPointInSphere, Point3F, (F32 radius), ,
    return MathUtils::randomPointInSphere(radius);
 }
 
-DefineConsoleFunction( mGetAngleBetweenVectors, F32, (VectorF vecA, VectorF vecB), ,
+DefineEngineFunction( mGetAngleBetweenVectors, F32, (VectorF vecA, VectorF vecB), ,
    "Returns angle between two vectors.\n"
    "@param vecA First input vector."
    "@param vecB Second input vector."
@@ -397,7 +397,7 @@ DefineConsoleFunction( mGetAngleBetweenVectors, F32, (VectorF vecA, VectorF vecB
    return MathUtils::getAngleBetweenVectors(vecA, vecB);
 }
 
-DefineConsoleFunction(mGetSignedAngleBetweenVectors, F32, (VectorF vecA, VectorF vecB, VectorF norm), (VectorF::Zero, VectorF::Zero, VectorF::Zero),
+DefineEngineFunction(mGetSignedAngleBetweenVectors, F32, (VectorF vecA, VectorF vecB, VectorF norm), (VectorF::Zero, VectorF::Zero, VectorF::Zero),
    "Returns signed angle between two vectors, using a normal for orientation.\n"
    "@param vecA First input vector."
    "@param vecB Second input vector."

Engine/source/math/mRotation.cpp

@@ -325,7 +325,7 @@ TEST(Maths, RotationF_Calculations)
 };
 #endif
 
-DefineConsoleFunction(AddRotation, RotationF, (RotationF a, RotationF b), ,
+DefineEngineFunction(AddRotation, RotationF, (RotationF a, RotationF b), ,
    "Adds two rotations together.\n"
    "@param a Rotation one."
    "@param b Rotation two."
@@ -335,7 +335,7 @@ DefineConsoleFunction(AddRotation, RotationF, (RotationF a, RotationF b), ,
    return a + b;
 }
  
-DefineConsoleFunction(SubtractRotation, RotationF, (RotationF a, RotationF b), ,
+DefineEngineFunction(SubtractRotation, RotationF, (RotationF a, RotationF b), ,
    "Subtracts two rotations.\n"
    "@param a Rotation one."
    "@param b Rotation two."
@@ -345,7 +345,7 @@ DefineConsoleFunction(SubtractRotation, RotationF, (RotationF a, RotationF b), ,
    return a - b;
 }
  
-DefineConsoleFunction(InterpolateRotation, RotationF, (RotationF a, RotationF b, F32 factor), ,
+DefineEngineFunction(InterpolateRotation, RotationF, (RotationF a, RotationF b, F32 factor), ,
    "Interpolates between two rotations.\n"
    "@param a Rotation one."
    "@param b Rotation two."
@@ -358,7 +358,7 @@ DefineConsoleFunction(InterpolateRotation, RotationF, (RotationF a, RotationF b,
    return result;
 }
  
-DefineConsoleFunction(RotationLookAt, RotationF, (Point3F origin, Point3F target, Point3F up),
+DefineEngineFunction(RotationLookAt, RotationF, (Point3F origin, Point3F target, Point3F up),
    (Point3F(0, 0, 0), Point3F(0, 0, 0), Point3F(0, 0, 1)),
    "Provides a rotation orientation to look at a target from a given position.\n"
    "@param origin Position of the object doing the looking."
@@ -372,7 +372,7 @@ DefineConsoleFunction(RotationLookAt, RotationF, (Point3F origin, Point3F target
    return result;
 }
 
-DefineConsoleFunction(setRotationRightVector, RotationF, (RotationF rot, VectorF rightVec), ,
+DefineEngineFunction(setRotationRightVector, RotationF, (RotationF rot, VectorF rightVec), ,
    "Sets the right vector of the rotation.\n"
    "@param Starting rotation."
    "@param New up vector."
@@ -383,7 +383,7 @@ DefineConsoleFunction(setRotationRightVector, RotationF, (RotationF rot, VectorF
    return rot;
 }
 
-DefineConsoleFunction(setRotationUpVector, RotationF, (RotationF rot, VectorF upVec), ,
+DefineEngineFunction(setRotationUpVector, RotationF, (RotationF rot, VectorF upVec), ,
    "Sets the up vector of the rotation.\n"
    "@param Starting rotation."
    "@param New up vector."
@@ -394,14 +394,14 @@ DefineConsoleFunction(setRotationUpVector, RotationF, (RotationF rot, VectorF up
    return rot;
 }
 
-DefineConsoleFunction(getRotationForwardVector, VectorF, (RotationF rot), ,
+DefineEngineFunction(getRotationForwardVector, VectorF, (RotationF rot), ,
    "Get the forward vector of a rotation.\n"
    "@ingroup Math")
 {
    return rot.asMatrixF().getForwardVector();
 }
 
-DefineConsoleFunction(getRotationRightVector, VectorF, (RotationF rot), ,
+DefineEngineFunction(getRotationRightVector, VectorF, (RotationF rot), ,
    "Gets the right vector of a rotation.\n"
    "@param Our rotation."
    "@ingroup Math")
@@ -409,7 +409,7 @@ DefineConsoleFunction(getRotationRightVector, VectorF, (RotationF rot), ,
    return rot.asMatrixF().getRightVector();
 }
 
-DefineConsoleFunction(getRotationUpVector, VectorF, (RotationF rot), ,
+DefineEngineFunction(getRotationUpVector, VectorF, (RotationF rot), ,
    "Gets the up vector of a rotation.\n"
    "@param Our rotation."
    "@ingroup Math")
@@ -417,7 +417,7 @@ DefineConsoleFunction(getRotationUpVector, VectorF, (RotationF rot), ,
    return rot.asMatrixF().getUpVector();
 }
 
-DefineConsoleFunction(getRotationDirection, Point3F, (RotationF rot),,
+DefineEngineFunction(getRotationDirection, Point3F, (RotationF rot),,
    "Gets the direction from the rotation's angles.\n"
    "@param Our rotation."
    "@ingroup Math")

Engine/source/math/mathTypes.cpp

@@ -631,7 +631,7 @@ ConsoleSetType(TypeRotationF)
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( VectorAdd, VectorF, ( VectorF a, VectorF b ),,
+DefineEngineFunction( VectorAdd, VectorF, ( VectorF a, VectorF b ),,
    "Add two vectors.\n"
    "@param a The first vector.\n"
    "@param b The second vector.\n"
@@ -659,7 +659,7 @@ DefineConsoleFunction( VectorAdd, VectorF, ( VectorF a, VectorF b ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( VectorSub, VectorF, ( VectorF a, VectorF b ),,
+DefineEngineFunction( VectorSub, VectorF, ( VectorF a, VectorF b ),,
    "Subtract two vectors.\n"
    "@param a The first vector.\n"
    "@param b The second vector.\n"
@@ -689,7 +689,7 @@ DefineConsoleFunction( VectorSub, VectorF, ( VectorF a, VectorF b ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( VectorScale, VectorF, ( VectorF a, F32 scalar ),,
+DefineEngineFunction( VectorScale, VectorF, ( VectorF a, F32 scalar ),,
    "Scales a vector by a scalar.\n"
    "@param a The vector to scale.\n"
    "@param scalar The scale factor.\n"
@@ -716,7 +716,7 @@ DefineConsoleFunction( VectorScale, VectorF, ( VectorF a, F32 scalar ),,
 {
    return a * scalar;
 }
-DefineConsoleFunction( VectorMul, VectorF, ( VectorF a, VectorF b ),,
+DefineEngineFunction( VectorMul, VectorF, ( VectorF a, VectorF b ),,
    "Multiplies two vectors.\n"
    "@param a The first vector.\n"
    "@param b The second vector.\n"
@@ -744,7 +744,7 @@ DefineConsoleFunction( VectorMul, VectorF, ( VectorF a, VectorF b ),,
    return a * b;
 }
 
-DefineConsoleFunction( VectorDiv, VectorF, ( VectorF a, VectorF b ),,
+DefineEngineFunction( VectorDiv, VectorF, ( VectorF a, VectorF b ),,
    "Divide two vectors.\n"
    "@param a The first vector.\n"
    "@param b The second vector.\n"
@@ -779,7 +779,7 @@ DefineConsoleFunction( VectorDiv, VectorF, ( VectorF a, VectorF b ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( VectorNormalize, VectorF, ( VectorF v ),,
+DefineEngineFunction( VectorNormalize, VectorF, ( VectorF v ),,
    "Brings a vector into its unit form, i.e. such that it has the magnitute 1.\n"
    "@param v The vector to normalize.\n"
    "@return The vector @a v scaled to length 1.\n\n"
@@ -811,7 +811,7 @@ DefineConsoleFunction( VectorNormalize, VectorF, ( VectorF v ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( VectorDot, F32, ( VectorF a, VectorF b ),,
+DefineEngineFunction( VectorDot, F32, ( VectorF a, VectorF b ),,
    "Compute the dot product of two vectors.\n"
    "@param a The first vector.\n"
    "@param b The second vector.\n"
@@ -841,7 +841,7 @@ DefineConsoleFunction( VectorDot, F32, ( VectorF a, VectorF b ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( VectorCross, VectorF, ( VectorF a, VectorF b ),,
+DefineEngineFunction( VectorCross, VectorF, ( VectorF a, VectorF b ),,
    "Calculcate the cross product of two vectors.\n"
    "@param a The first vector.\n"
    "@param b The second vector.\n"
@@ -873,7 +873,7 @@ DefineConsoleFunction( VectorCross, VectorF, ( VectorF a, VectorF b ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( VectorDist, F32, ( VectorF a, VectorF b ),,
+DefineEngineFunction( VectorDist, F32, ( VectorF a, VectorF b ),,
    "Compute the distance between two vectors.\n"
    "@param a The first vector.\n"
    "@param b The second vector.\n"
@@ -906,7 +906,7 @@ DefineConsoleFunction( VectorDist, F32, ( VectorF a, VectorF b ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( VectorMidPoint, VectorF, ( VectorF a, VectorF b ),,
+DefineEngineFunction( VectorMidPoint, VectorF, ( VectorF a, VectorF b ),,
    "Gets the midpoint between the two vectors.\n"
    "@param a The first vector.\n"
    "@param b The second vector.\n"
@@ -934,7 +934,7 @@ DefineConsoleFunction( VectorMidPoint, VectorF, ( VectorF a, VectorF b ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( VectorLen, F32, ( VectorF v ),,
+DefineEngineFunction( VectorLen, F32, ( VectorF v ),,
    "Calculate the magnitude of the given vector.\n"
    "@param v A vector.\n"
    "@return The length of vector @a v.\n\n"
@@ -963,7 +963,7 @@ DefineConsoleFunction( VectorLen, F32, ( VectorF v ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( VectorOrthoBasis, MatrixF, ( AngAxisF aa ),,
+DefineEngineFunction( VectorOrthoBasis, MatrixF, ( AngAxisF aa ),,
    "Create an orthogonal basis from the given vector.\n"
    "@param aaf The vector to create the orthogonal basis from.\n"
    "@return A matrix representing the orthogonal basis.\n"
@@ -977,7 +977,7 @@ DefineConsoleFunction( VectorOrthoBasis, MatrixF, ( AngAxisF aa ),,
 //-----------------------------------------------------------------------------
 
 //ConsoleFunction(VectorRot, const char*, 3, 3, "(Vector3F, float) rotate a vector in 2d")
-DefineConsoleFunction( VectorRot, const char*, (Point3F v, F32 angle), , "(Vector3F, float) rotate a vector in 2d")
+DefineEngineFunction( VectorRot, const char*, (Point3F v, F32 angle), , "(Vector3F, float) rotate a vector in 2d")
 {
 	//VectorF v(0,0,0);
 	//dSscanf(argv[1],"%g %g %g",&v.x,&v.y,&v.z);
@@ -996,7 +996,7 @@ DefineConsoleFunction( VectorRot, const char*, (Point3F v, F32 angle), , "(Vecto
 	return returnBuffer;
 }
 
-DefineConsoleFunction( VectorLerp, VectorF, ( VectorF a, VectorF b, F32 t ),,
+DefineEngineFunction( VectorLerp, VectorF, ( VectorF a, VectorF b, F32 t ),,
    "Linearly interpolate between two vectors by @a t.\n"
    "@param a Vector to start interpolation from.\n"
    "@param b Vector to interpolate to.\n"
@@ -1032,7 +1032,7 @@ DefineConsoleFunction( VectorLerp, VectorF, ( VectorF a, VectorF b, F32 t ),,
    return c;
 }
 
-DefineConsoleFunction(VectorReflect, VectorF, (VectorF vec, VectorF normal), ,
+DefineEngineFunction(VectorReflect, VectorF, (VectorF vec, VectorF normal), ,
    "Compute the reflection of a vector based on a normal.\n"
    "@param a The vector.\n"
    "@param b The normal.\n"
@@ -1046,7 +1046,7 @@ DefineConsoleFunction(VectorReflect, VectorF, (VectorF vec, VectorF normal), ,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( MatrixCreate, TransformF, ( VectorF position, AngAxisF orientation ),,
+DefineEngineFunction( MatrixCreate, TransformF, ( VectorF position, AngAxisF orientation ),,
    "Create a transform from the given translation and orientation.\n"
    "@param position The translation vector for the transform.\n"
    "@param orientation The axis and rotation that orients the transform.\n"
@@ -1059,7 +1059,7 @@ DefineConsoleFunction( MatrixCreate, TransformF, ( VectorF position, AngAxisF or
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( MatrixCreateFromEuler, TransformF, ( Point3F angles ),,
+DefineEngineFunction( MatrixCreateFromEuler, TransformF, ( Point3F angles ),,
    "@Create a matrix from the given rotations.\n\n"
    "@param Vector3F X, Y, and Z rotation in *radians*.\n"
    "@return A transform based on the given orientation.\n"
@@ -1074,7 +1074,7 @@ DefineConsoleFunction( MatrixCreateFromEuler, TransformF, ( Point3F angles ),,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( MatrixMultiply, TransformF, ( TransformF left, TransformF right ),,
+DefineEngineFunction( MatrixMultiply, TransformF, ( TransformF left, TransformF right ),,
    "@brief Multiply the two matrices.\n\n"
    "@param left First transform.\n"
    "@param right Right transform.\n"
@@ -1091,7 +1091,7 @@ DefineConsoleFunction( MatrixMultiply, TransformF, ( TransformF left, TransformF
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( MatrixMulVector, VectorF, ( TransformF transform, VectorF vector ),,
+DefineEngineFunction( MatrixMulVector, VectorF, ( TransformF transform, VectorF vector ),,
    "@brief Multiply the vector by the transform assuming that w=0.\n\n"
    "This function will multiply the given vector by the given transform such that translation will "
    "not affect the vector.\n\n"
@@ -1107,7 +1107,7 @@ DefineConsoleFunction( MatrixMulVector, VectorF, ( TransformF transform, VectorF
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( MatrixMulPoint, Point3F, ( TransformF transform, Point3F point ),,
+DefineEngineFunction( MatrixMulPoint, Point3F, ( TransformF transform, Point3F point ),,
    "@brief Multiply the given point by the given transform assuming that w=1.\n\n"
    "This function will multiply the given vector such that translation with take effect.\n"
    "@param transform A transform.\n"
@@ -1124,7 +1124,7 @@ ConsoleFunctionGroupEnd(MatrixMath);
 
 //------------------------------------------------------------------------------
 
-DefineConsoleFunction( getBoxCenter, Point3F, ( Box3F box ),,
+DefineEngineFunction( getBoxCenter, Point3F, ( Box3F box ),,
    "Get the center point of an axis-aligned box.\n\n"
    "@param b A Box3F, in string format using \"minExtentX minExtentY minExtentZ maxExtentX maxExtentY maxExtentZ\"\n"
    "@return Center of the box.\n"
@@ -1176,7 +1176,7 @@ F32 mRandF()
    return gRandGen.randF();
 }
 
-DefineConsoleFunction(getRandom, F32, (S32 a, S32 b), (S32_MAX, S32_MAX),
+DefineEngineFunction(getRandom, F32, (S32 a, S32 b), (S32_MAX, S32_MAX),
    "( int a, int b ) "
    "@brief Returns a random number based on parameters passed in..\n\n"
    "If no parameters are passed in, getRandom() will return a float between 0.0 and 1.0. If one "

Engine/source/navigation/navMesh.cpp

@@ -95,13 +95,13 @@ EventManager *NavMesh::getEventManager()
    return smEventManager;
 }
 
-DefineConsoleFunction(getNavMeshEventManager, S32, (),,
+DefineEngineFunction(getNavMeshEventManager, S32, (),,
    "@brief Get the EventManager object for all NavMesh updates.")
 {
    return NavMesh::getEventManager()->getId();
 }
 
-DefineConsoleFunction(NavMeshUpdateAll, void, (S32 objid, bool remove), (0, false),
+DefineEngineFunction(NavMeshUpdateAll, void, (S32 objid, bool remove), (0, false),
    "@brief Update all NavMesh tiles that intersect the given object's world box.")
 {
    SceneObject *obj;
@@ -123,7 +123,7 @@ DefineConsoleFunction(NavMeshUpdateAll, void, (S32 objid, bool remove), (0, fals
       obj->enableCollision();
 }
 
-DefineConsoleFunction(NavMeshUpdateAroundObject, void, (S32 objid, bool remove), (0, false),
+DefineEngineFunction(NavMeshUpdateAroundObject, void, (S32 objid, bool remove), (0, false),
    "@brief Update all NavMesh tiles that intersect the given object's world box.")
 {
    SceneObject *obj;
@@ -146,7 +146,7 @@ DefineConsoleFunction(NavMeshUpdateAroundObject, void, (S32 objid, bool remove),
 }
 
 
-DefineConsoleFunction(NavMeshIgnore, void, (S32 objid, bool _ignore), (0, true),
+DefineEngineFunction(NavMeshIgnore, void, (S32 objid, bool _ignore), (0, true),
    "@brief Flag this object as not generating a navmesh result.")
 {
    SceneObject *obj;
@@ -156,7 +156,7 @@ DefineConsoleFunction(NavMeshIgnore, void, (S32 objid, bool _ignore), (0, true),
       obj->mPathfindingIgnore = _ignore;
 }
 
-DefineConsoleFunction(NavMeshUpdateOne, void, (S32 meshid, S32 objid, bool remove), (0, 0, false),
+DefineEngineFunction(NavMeshUpdateOne, void, (S32 meshid, S32 objid, bool remove), (0, 0, false),
    "@brief Update all tiles in a given NavMesh that intersect the given object's world box.")
 {
    NavMesh *mesh;

Engine/source/platform/platformFileIO.cpp

@@ -38,7 +38,7 @@ StringTableEntry Platform::getTemporaryDirectory()
    return path;
 }
 
-DefineConsoleFunction( getTemporaryDirectory, const char *, (), ,
+DefineEngineFunction( getTemporaryDirectory, const char *, (), ,
 				"@brief Returns the OS temporary directory, \"C:/Users/Mich/AppData/Local/Temp\" for example\n\n"
 				"@note This can be useful to adhering to OS standards and practices, "
 				"but not really used in Torque 3D right now.\n"
@@ -66,7 +66,7 @@ StringTableEntry Platform::getTemporaryFileName()
    return StringTable->insert(buf);
 }
 
-DefineConsoleFunction( getTemporaryFileName, const char *, (), ,
+DefineEngineFunction( getTemporaryFileName, const char *, (), ,
 				"@brief Creates a name and extension for a potential temporary file\n\n"
 				"This does not create the actual file. It simply creates a random name "
 				"for a file that does not exist.\n\n"
@@ -611,12 +611,12 @@ StringTableEntry Platform::getPrefsPath(const char *file /* = NULL */)
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( getUserDataDirectory, const char *, (), , "getUserDataDirectory()")
+DefineEngineFunction( getUserDataDirectory, const char *, (), , "getUserDataDirectory()")
 {
    return Platform::getUserDataDirectory();
 }
 
-DefineConsoleFunction( getUserHomeDirectory, const char *, (), , "getUserHomeDirectory()")
+DefineEngineFunction( getUserHomeDirectory, const char *, (), , "getUserHomeDirectory()")
 {
    return Platform::getUserHomeDirectory();
 }

Engine/source/platform/platformMemory.cpp

@@ -885,7 +885,7 @@ void logDumpTraverse(MemDumpLog *sizes, TreeNode *header, U32 depth)
 }
 
 #ifdef TORQUE_DEBUG
-DefineConsoleFunction( validateMemory, void, ( ),,
+DefineEngineFunction( validateMemory, void, ( ),,
    "@brief Used to validate memory space for the game.\n\n"
    "@ingroup Debugging" )
 {
@@ -893,7 +893,7 @@ DefineConsoleFunction( validateMemory, void, ( ),,
 }
 #endif
 
-DefineConsoleFunction( freeMemoryDump, void, ( ),,
+DefineEngineFunction( freeMemoryDump, void, ( ),,
    "@brief Dumps some useful statistics regarding free memory.\n\n"
    "Dumps an analysis of \'free chunks\' of memory. "
    "Does not print how much memory is free.\n\n"

Engine/source/platform/platformRedBook.cpp

@@ -211,7 +211,7 @@ bool RedBook::setVolume(F32 volume)
 
 ConsoleFunctionGroupBegin( Redbook, "Control functions for Redbook audio (ie, CD audio).");
 
-DefineConsoleFunction( redbookOpen, bool, (const char * device), (""), "(string device=NULL)"
+DefineEngineFunction( redbookOpen, bool, (const char * device), (""), "(string device=NULL)"
 				"@brief Deprecated\n\n"
 				"@internal")
 {
@@ -221,28 +221,28 @@ DefineConsoleFunction( redbookOpen, bool, (const char * device), (""), "(string
       return(RedBook::open(device));
 }
 
-DefineConsoleFunction( redbookClose, bool, (), , "Close the current Redbook device."
+DefineEngineFunction( redbookClose, bool, (), , "Close the current Redbook device."
 				"@brief Deprecated\n\n"
 				"@internal")
 {
    return(RedBook::close());
 }
 
-DefineConsoleFunction( redbookPlay, bool, (S32 track), , "(int track) Play the selected track."
+DefineEngineFunction( redbookPlay, bool, (S32 track), , "(int track) Play the selected track."
 				"@brief Deprecated\n\n"
 				"@internal")
 {
    return(RedBook::play(track));
 }
 
-DefineConsoleFunction( redbookStop, bool, (), , "Stop playing."
+DefineEngineFunction( redbookStop, bool, (), , "Stop playing."
 				"@brief Deprecated\n\n"
 				"@internal")
 {
    return(RedBook::stop());
 }
 
-DefineConsoleFunction( redbookGetTrackCount, S32, (), , "Return the number of tracks."
+DefineEngineFunction( redbookGetTrackCount, S32, (), , "Return the number of tracks."
 				"@brief Deprecated\n\n"
 				"@internal")
 {
@@ -252,7 +252,7 @@ DefineConsoleFunction( redbookGetTrackCount, S32, (), , "Return the number of tr
    return(trackCount);
 }
 
-DefineConsoleFunction( redbookGetVolume, F32, (), , "Get the volume."
+DefineEngineFunction( redbookGetVolume, F32, (), , "Get the volume."
 				"@brief Deprecated\n\n"
 				"@internal")
 {
@@ -263,28 +263,28 @@ DefineConsoleFunction( redbookGetVolume, F32, (), , "Get the volume."
       return(vol);
 }
 
-DefineConsoleFunction( redbookSetVolume, bool, (F32 volume), , "(float volume) Set playback volume."
+DefineEngineFunction( redbookSetVolume, bool, (F32 volume), , "(float volume) Set playback volume."
 				"@brief Deprecated\n\n"
 				"@internal")
 {
    return(RedBook::setVolume(volume));
 }
 
-DefineConsoleFunction( redbookGetDeviceCount, S32, (), , "get the number of redbook devices."
+DefineEngineFunction( redbookGetDeviceCount, S32, (), , "get the number of redbook devices."
 				"@brief Deprecated\n\n"
 				"@internal")
 {
    return(RedBook::getDeviceCount());
 }
 
-DefineConsoleFunction( redbookGetDeviceName, const char *, (S32 index), , "(int index) Get name of specified Redbook device."
+DefineEngineFunction( redbookGetDeviceName, const char *, (S32 index), , "(int index) Get name of specified Redbook device."
 				"@brief Deprecated\n\n"
 				"@internal")
 {
    return(RedBook::getDeviceName(index));
 }
 
-DefineConsoleFunction( redbookGetLastError, const char *, (), , "Get a string explaining the last redbook error."
+DefineEngineFunction( redbookGetLastError, const char *, (), , "Get a string explaining the last redbook error."
 				"@brief Deprecated\n\n"
 				"@internal")
 {

Engine/source/platform/platformTimer.cpp

@@ -160,12 +160,12 @@ S32 ScriptTimerMan::stopTimer( S32 id )
 
 ScriptTimerMan gScriptTimerMan;
 
-DefineConsoleFunction( startPrecisionTimer, S32, (), , "startPrecisionTimer() - Create and start a high resolution platform timer. Returns the timer id." )
+DefineEngineFunction( startPrecisionTimer, S32, (), , "startPrecisionTimer() - Create and start a high resolution platform timer. Returns the timer id." )
 {
    return gScriptTimerMan.startTimer();
 }
 
-DefineConsoleFunction( stopPrecisionTimer, S32, ( S32 id), , "stopPrecisionTimer( S32 id ) - Stop and destroy timer with the passed id.  Returns the elapsed milliseconds." )
+DefineEngineFunction( stopPrecisionTimer, S32, ( S32 id), , "stopPrecisionTimer( S32 id ) - Stop and destroy timer with the passed id.  Returns the elapsed milliseconds." )
 {
    return gScriptTimerMan.stopTimer( id );
 }

Engine/source/platformWin32/cardProfile.cpp

@@ -74,7 +74,7 @@ void initDisplayDeviceInfo()
    Con::setVariable( "$PCI_DEV", dev );
 }
 
-DefineConsoleFunction( initDisplayDeviceInfo, void, (), , "()"
+DefineEngineFunction( initDisplayDeviceInfo, void, (), , "()"
 				"@brief Initializes variables that track device and vendor information/IDs\n\n"
 				"@ingroup Rendering")
 {

Engine/source/platformWin32/winConsole.cpp

@@ -38,7 +38,7 @@ namespace Con
    extern bool alwaysUseDebugOutput;
 }
 
-DefineConsoleFunction( enableWinConsole, void, (bool flag), , "enableWinConsole(bool);")
+DefineEngineFunction( enableWinConsole, void, (bool flag), , "enableWinConsole(bool);")
 {
    WindowsConsole->enable(flag);
 }

Engine/source/platformWin32/winDirectInput.cpp

@@ -769,7 +769,7 @@ void DInputManager::processXInput( void )
          mXInputStateReset = false;
    }
 }
-DefineConsoleFunction( enableJoystick, bool, (), , "()"
+DefineEngineFunction( enableJoystick, bool, (), , "()"
              "@brief Enables use of the joystick.\n\n"
              "@note DirectInput must be enabled and active to use this function.\n\n"
              "@ingroup Input")
@@ -778,7 +778,7 @@ DefineConsoleFunction( enableJoystick, bool, (), , "()"
 }
 
 //------------------------------------------------------------------------------
-DefineConsoleFunction( disableJoystick, void, (), , "()"
+DefineEngineFunction( disableJoystick, void, (), , "()"
              "@brief Disables use of the joystick.\n\n"
              "@note DirectInput must be enabled and active to use this function.\n\n"
              "@ingroup Input")
@@ -787,7 +787,7 @@ DefineConsoleFunction( disableJoystick, void, (), , "()"
 }
 
 //------------------------------------------------------------------------------
-DefineConsoleFunction( isJoystickEnabled, bool, (), , "()"
+DefineEngineFunction( isJoystickEnabled, bool, (), , "()"
 				"@brief Queries input manager to see if a joystick is enabled\n\n"
 				"@return 1 if a joystick exists and is enabled, 0 if it's not.\n"
 				"@ingroup Input")
@@ -796,7 +796,7 @@ DefineConsoleFunction( isJoystickEnabled, bool, (), , "()"
 }
 
 //------------------------------------------------------------------------------
-DefineConsoleFunction( enableXInput, bool, (), , "()"
+DefineEngineFunction( enableXInput, bool, (), , "()"
             "@brief Enables XInput for Xbox 360 controllers.\n\n"
             "@note XInput is enabled by default. Disable to use an Xbox 360 "
             "Controller as a joystick device.\n\n"
@@ -811,7 +811,7 @@ DefineConsoleFunction( enableXInput, bool, (), , "()"
 }
 
 //------------------------------------------------------------------------------
-DefineConsoleFunction( disableXInput, void, (), , "()"
+DefineEngineFunction( disableXInput, void, (), , "()"
             "@brief Disables XInput for Xbox 360 controllers.\n\n"
             "@ingroup Input")
 {
@@ -819,7 +819,7 @@ DefineConsoleFunction( disableXInput, void, (), , "()"
 }
 
 //------------------------------------------------------------------------------
-DefineConsoleFunction( resetXInput, void, (), , "()"
+DefineEngineFunction( resetXInput, void, (), , "()"
             "@brief Rebuilds the XInput section of the InputManager\n\n"
             "Requests a full refresh of events for all controllers. Useful when called at the beginning "
             "of game code after actionMaps are set up to hook up all appropriate events.\n\n"
@@ -836,7 +836,7 @@ DefineConsoleFunction( resetXInput, void, (), , "()"
 }
 
 //------------------------------------------------------------------------------
-DefineConsoleFunction( isXInputConnected, bool, (S32 controllerID), , "( int controllerID )"
+DefineEngineFunction( isXInputConnected, bool, (S32 controllerID), , "( int controllerID )"
 				"@brief Checks to see if an Xbox 360 controller is connected\n\n"
 				"@param controllerID Zero-based index of the controller to check.\n"
             "@return 1 if the controller is connected, 0 if it isn't, and 205 if XInput "
@@ -849,7 +849,7 @@ DefineConsoleFunction( isXInputConnected, bool, (S32 controllerID), , "( int con
 }
 
 //------------------------------------------------------------------------------
-DefineConsoleFunction( getXInputState, int, (S32 controllerID, const char * properties, bool current), (false), "( int controllerID, string property, bool currentD )"
+DefineEngineFunction( getXInputState, int, (S32 controllerID, const char * properties, bool current), (false), "( int controllerID, string property, bool currentD )"
 				"@brief Queries the current state of a connected Xbox 360 controller.\n\n"
             "XInput Properties:\n\n"
             " - XI_THUMBLX, XI_THUMBLY - X and Y axes of the left thumbstick. \n"
@@ -905,7 +905,7 @@ DefineConsoleFunction( getXInputState, int, (S32 controllerID, const char * prop
 }
 
 //------------------------------------------------------------------------------
-DefineConsoleFunction( echoInputState, void, (), , "()"
+DefineEngineFunction( echoInputState, void, (), , "()"
             "@brief Prints information to the console stating if DirectInput and a Joystick are enabled and active.\n\n"
             "@ingroup Input")
 {
@@ -921,7 +921,7 @@ DefineConsoleFunction( echoInputState, void, (), , "()"
       Con::printf( "DirectInput is not enabled." );
 }
 
-DefineConsoleFunction( rumble, void, (const char * device, F32 xRumble, F32 yRumble), , "(string device, float xRumble, float yRumble)"
+DefineEngineFunction( rumble, void, (const char * device, F32 xRumble, F32 yRumble), , "(string device, float xRumble, float yRumble)"
       "@brief Activates the vibration motors in the specified controller.\n\n"
       "The controller will constantly at it's xRumble and yRumble intensities until "
       "changed or told to stop."

Engine/source/platformWin32/winExec.cpp

@@ -136,7 +136,7 @@ void ExecuteThread::run(void *arg /* = 0 */)
 // Console Functions
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( shellExecute, bool, (const char * executable, const char * args, const char * directory), ("", ""), "(string executable, string args, string directory)"
+DefineEngineFunction( shellExecute, bool, (const char * executable, const char * args, const char * directory), ("", ""), "(string executable, string args, string directory)"
 				"@brief Launches an outside executable or batch file\n\n"
 				"@param executable Name of the executable or batch file\n"
 				"@param args Optional list of arguments, in string format, to pass to the executable\n"

Engine/source/platformWin32/winInput.cpp

@@ -157,13 +157,13 @@ void Input::init()
 }
 
 //------------------------------------------------------------------------------
-DefineConsoleFunction( isJoystickDetected, bool, (), , "isJoystickDetected()")
+DefineEngineFunction( isJoystickDetected, bool, (), , "isJoystickDetected()")
 {
    return( DInputDevice::joystickDetected() );
 }
 
 //------------------------------------------------------------------------------
-DefineConsoleFunction( getJoystickAxes, const char*, (U32 deviceID), , "getJoystickAxes( instance )")
+DefineEngineFunction( getJoystickAxes, const char*, (U32 deviceID), , "getJoystickAxes( instance )")
 {
    DInputManager* mgr = dynamic_cast<DInputManager*>( Input::getManager() );
    if ( mgr )
@@ -505,7 +505,7 @@ void Input::log( const char* format, ... )
    va_end( argptr );
 }
 
-DefineConsoleFunction( inputLog, void, (const char * log), , "inputLog( string )")
+DefineEngineFunction( inputLog, void, (const char * log), , "inputLog( string )")
 {
    Input::log( "%s\n", log );
 }

Engine/source/platformWin32/winWindow.cpp

@@ -643,7 +643,7 @@ bool Platform::setLoginPassword( const char* password )
 //       as commentary on Koreans as a nationality. Thank you for your
 //       attention.
 //--------------------------------------
-DefineConsoleFunction( isKoreanBuild, bool, ( ), , "isKoreanBuild()")
+DefineEngineFunction( isKoreanBuild, bool, ( ), , "isKoreanBuild()")
 {
    HKEY regKey;
    bool result = false;

Engine/source/scene/pathManager.cpp

@@ -207,12 +207,12 @@ void PathManager::clearPaths()
 #endif
 }
 
-DefineConsoleFunction( clearServerPaths, void, ( ), , "")
+DefineEngineFunction( clearServerPaths, void, ( ), , "")
 {
    gServerPathManager->clearPaths();
 }
 
-DefineConsoleFunction( clearClientPaths, void, ( ), , "")
+DefineEngineFunction( clearClientPaths, void, ( ), , "")
 {
    gClientPathManager->clearPaths();
 }

Engine/source/scene/sceneManager.cpp

@@ -720,7 +720,7 @@ RenderPassManager* SceneManager::getDefaultRenderPass() const
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( sceneDumpZoneStates, void, ( bool updateFirst ), ( true ),
+DefineEngineFunction( sceneDumpZoneStates, void, ( bool updateFirst ), ( true ),
    "Dump the current zoning states of all zone spaces in the scene to the console.\n\n"
    "@param updateFirst If true, zoning states are brought up to date first; if false, the zoning states "
    "are dumped as is.\n\n"
@@ -745,7 +745,7 @@ DefineConsoleFunction( sceneDumpZoneStates, void, ( bool updateFirst ), ( true )
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( sceneGetZoneOwner, SceneObject*, ( U32 zoneId ),,
+DefineEngineFunction( sceneGetZoneOwner, SceneObject*, ( U32 zoneId ),,
    "Return the SceneObject that contains the given zone.\n\n"
    "@param zoneId ID of zone.\n"
    "@return A SceneObject or NULL if the given @a zoneId is invalid.\n\n"

Engine/source/sfx/sfxSystem.cpp

@@ -1442,7 +1442,7 @@ static ConsoleDocFragment _sfxCreateSource4(
    NULL,
    "SFXSound sfxCreateSource( SFXDescription description, string filename, float x, float y, float z );" );
 
-DefineConsoleFunction( sfxCreateSource, S32, ( const char * sfxType, const char * arg0, const char * arg1, const char * arg2, const char * arg3 ), ("", "", "", ""),
+DefineEngineFunction( sfxCreateSource, S32, ( const char * sfxType, const char * arg0, const char * arg1, const char * arg2, const char * arg3 ), ("", "", "", ""),
                      "( SFXTrack track | ( SFXDescription description, string filename ) [, float x, float y, float z ] ) "
                      "Creates a new paused sound source using a profile or a description "
                      "and filename.  The return value is the source which must be "
@@ -1547,7 +1547,7 @@ static ConsoleDocFragment _sfxPlay3(
    NULL,
    "void sfxPlay( SFXTrack track, float x, float y, float z );" );
    
-DefineConsoleFunction( sfxPlay, S32, ( const char * trackName, const char * pointOrX, const char * y, const char * z ), ( "", "", ""),
+DefineEngineFunction( sfxPlay, S32, ( const char * trackName, const char * pointOrX, const char * y, const char * z ), ( "", "", ""),
    "Start playing the given source or create a new source for the given track and play it.\n"
    "@hide" )
 {
@@ -1657,7 +1657,7 @@ static ConsoleDocFragment _sPlayOnce4(
    "SFXSource sfxPlayOnce( SFXDescription description, string filename, float x, float y, float z, float fadeInTime=-1 );"
 );
 
-DefineConsoleFunction( sfxPlayOnce, S32, ( const char * sfxType, const char * arg0, const char * arg1, const char * arg2, const char * arg3, const char* arg4 ), ("", "", "", "", "-1.0f"),
+DefineEngineFunction( sfxPlayOnce, S32, ( const char * sfxType, const char * arg0, const char * arg1, const char * arg2, const char * arg3, const char* arg4 ), ("", "", "", "", "-1.0f"),
    "SFXSource sfxPlayOnce( ( SFXTrack track | SFXDescription description, string filename ) [, float x, float y, float z, float fadeInTime=-1 ] ) "
    "Create a new play-once source for the given profile or description+filename and start playback of the source.\n"
    "@hide" )

Engine/source/sim/netInterface.cpp

@@ -638,7 +638,7 @@ void NetInterface::computeNetMD5(const NetAddress *address, U32 connectSequence,
 
 ConsoleFunctionGroupBegin(NetInterface, "Global control functions for the netInterfaces.");
 
-DefineConsoleFunction( allowConnections, void, ( bool allow ), , "allowConnections(bool allow)"
+DefineEngineFunction( allowConnections, void, ( bool allow ), , "allowConnections(bool allow)"
    "@brief Sets whether or not the global NetInterface allows connections from remote hosts.\n\n"
 
    "@param allow Set to true to allow remote connections.\n"

Engine/source/terrain/terrData.cpp

@@ -147,7 +147,7 @@ ConsoleDocFragment _getTerrainUnderWorldPoint2(
    "bool getTerrainUnderWorldPoint( F32 x, F32 y, F32 z);"
 );
 
-DefineConsoleFunction( getTerrainUnderWorldPoint, S32, (const char* ptOrX, const char* y, const char* z), ("", ""),
+DefineEngineFunction( getTerrainUnderWorldPoint, S32, (const char* ptOrX, const char* y, const char* z), ("", ""),
                                                       "(Point3F x/y/z) Gets the terrain block that is located under the given world point.\n"
                                                       "@param x/y/z The world coordinates (floating point values) you wish to query at. " 
                                                       "These can be formatted as either a string (\"x y z\") or separately as (x, y, z)\n"
@@ -1338,7 +1338,7 @@ ConsoleDocFragment _getTerrainHeight2(
    "bool getTerrainHeight( F32 x, F32 y);"
 );
 
-DefineConsoleFunction( getTerrainHeight, F32, (const char* ptOrX, const char* y), (""), "(Point2 pos) - gets the terrain height at the specified position."
+DefineEngineFunction( getTerrainHeight, F32, (const char* ptOrX, const char* y), (""), "(Point2 pos) - gets the terrain height at the specified position."
 				"@param pos The world space point, minus the z (height) value\n Can be formatted as either (\"x y\") or (x,y)\n"
 				"@return Returns the terrain height at the given point as an F32 value.\n"
 				"@hide")
@@ -1383,7 +1383,7 @@ ConsoleDocFragment _getTerrainHeightBelowPosition2(
    "bool getTerrainHeightBelowPosition( F32 x, F32 y);"
 );
 
-DefineConsoleFunction( getTerrainHeightBelowPosition, F32, (const char* ptOrX, const char* y, const char* z), ("", ""),
+DefineEngineFunction( getTerrainHeightBelowPosition, F32, (const char* ptOrX, const char* y, const char* z), ("", ""),
             "(Point3F pos) - gets the terrain height at the specified position."
 				"@param pos The world space point. Can be formatted as either (\"x y z\") or (x,y,z)\n"
 				"@note This function is useful if you simply want to grab the terrain height underneath an object.\n"

Engine/source/ts/collada/colladaImport.cpp

@@ -126,7 +126,7 @@ static void processNode(GuiTreeViewCtrl* tree, domNode* node, S32 parentID, Scen
    }
 }
 
-DefineConsoleFunction( enumColladaForImport, bool, (const char * shapePath, const char * ctrl), , 
+DefineEngineFunction( enumColladaForImport, bool, (const char * shapePath, const char * ctrl), ,
    "(string shapePath, GuiTreeViewCtrl ctrl) Collect scene information from "
    "a COLLADA file and store it in a GuiTreeView control. This function is "
    "used by the COLLADA import gui to show a preview of the scene contents "

Engine/source/ts/collada/colladaLights.cpp

@@ -139,7 +139,7 @@ static void processNodeLights(AppNode* appNode, const MatrixF& offset, SimGroup*
 }
 
 // Load lights from a collada file and add to the scene.
-DefineConsoleFunction( loadColladaLights, bool, (const char * filename, const char * parentGroup, const char * baseObject), ("", ""), 
+DefineEngineFunction( loadColladaLights, bool, (const char * filename, const char * parentGroup, const char * baseObject), ("", ""),
    "(string filename, SimGroup parentGroup=MissionGroup, SimObject baseObject=-1)"
    "Load all light instances from a COLLADA (.dae) file and add to the scene.\n"
    "@param filename COLLADA filename to load lights from\n"

Engine/source/ts/loader/tsShapeLoader.cpp

@@ -1325,14 +1325,14 @@ String TSShapeLoader::getFormatFilters()
    return output.end();
 }
 
-DefineConsoleFunction( getFormatExtensions, const char*, ( ),, 
+DefineEngineFunction( getFormatExtensions, const char*, ( ),, 
   "Returns a list of supported shape format extensions separated by tabs."
   "Example output: *.dsq TAB *.dae TAB")
 {
    return Con::getReturnBuffer(TSShapeLoader::getFormatExtensions());
 }
 
-DefineConsoleFunction( getFormatFilters, const char*, ( ),, 
+DefineEngineFunction( getFormatFilters, const char*, ( ),, 
   "Returns a list of supported shape formats in filter form.\n"
   "Example output: DSQ Files|*.dsq|COLLADA Files|*.dae|")
 {

Engine/source/ts/tsLastDetail.cpp

@@ -543,7 +543,7 @@ void TSLastDetail::updateImposterImages( bool forceUpdate )
       GFX->endScene();
 }
 
-DefineConsoleFunction( tsUpdateImposterImages, void, (bool forceUpdate), (false), "tsUpdateImposterImages( bool forceupdate )")
+DefineEngineFunction( tsUpdateImposterImages, void, (bool forceUpdate), (false), "tsUpdateImposterImages( bool forceupdate )")
 {
    TSLastDetail::updateImposterImages(forceUpdate);
 }

Engine/source/util/fpsTracker.cpp

@@ -88,7 +88,7 @@ void FPSTracker::update()
    }
 }
 
-DefineConsoleFunction( resetFPSTracker, void, (), , "()"
+DefineEngineFunction( resetFPSTracker, void, (), , "()"
    "@brief Reset FPS stats (fps::)\n\n"
    "@ingroup Game")
 {

Engine/source/util/messaging/dispatcher.cpp

@@ -331,7 +331,7 @@ extern void unlockDispatcherMutex()
 
 using namespace Dispatcher;
 
-DefineConsoleFunction( isQueueRegistered, bool, (const char * queueName), , "(string queueName)"
+DefineEngineFunction( isQueueRegistered, bool, (const char * queueName), , "(string queueName)"
 				"@brief Determines if a dispatcher queue exists\n\n"
 				"@param queueName String containing the name of queue\n"
 				"@ingroup Messaging")
@@ -339,7 +339,7 @@ DefineConsoleFunction( isQueueRegistered, bool, (const char * queueName), , "(st
    return Dispatcher::isQueueRegistered(queueName);
 }
 
-DefineConsoleFunction( registerMessageQueue, void, (const char *queueName), , "(string queueName)"
+DefineEngineFunction( registerMessageQueue, void, (const char *queueName), , "(string queueName)"
 				"@brief Registeres a dispatcher queue\n\n"
 				"@param queueName String containing the name of queue\n"
 				"@ingroup Messaging")
@@ -347,7 +347,7 @@ DefineConsoleFunction( registerMessageQueue, void, (const char *queueName), , "(
    return Dispatcher::registerMessageQueue(queueName);
 }
 
-DefineConsoleFunction( unregisterMessageQueue, void, (const char *queueName), , "(string queueName)"
+DefineEngineFunction( unregisterMessageQueue, void, (const char *queueName), , "(string queueName)"
 				"@brief Unregisters a dispatcher queue\n\n"
 				"@param queueName String containing the name of queue\n"
 				"@ingroup Messaging")
@@ -357,7 +357,7 @@ DefineConsoleFunction( unregisterMessageQueue, void, (const char *queueName), ,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( registerMessageListener, bool, (const char *queueName, const char *listenerName), , "(string queueName, string listener)"
+DefineEngineFunction( registerMessageListener, bool, (const char *queueName, const char *listenerName), , "(string queueName, string listener)"
 				"@brief Registers an event message\n\n"
 				"@param queueName String containing the name of queue to attach listener to\n"
 				"@param listener Name of event messenger\n"
@@ -373,7 +373,7 @@ DefineConsoleFunction( registerMessageListener, bool, (const char *queueName, co
    return Dispatcher::registerMessageListener(queueName, listener);
 }
 
-DefineConsoleFunction( unregisterMessageListener, void, (const char *queueName, const char *listenerName), , "(string queueName, string listener)"
+DefineEngineFunction( unregisterMessageListener, void, (const char *queueName, const char *listenerName), , "(string queueName, string listener)"
 				"@brief Unregisters an event message\n\n"
 				"@param queueName String containing the name of queue\n"
 				"@param listener Name of event messenger\n"
@@ -391,7 +391,7 @@ DefineConsoleFunction( unregisterMessageListener, void, (const char *queueName,
 
 //-----------------------------------------------------------------------------
 
-DefineConsoleFunction( dispatchMessage, bool, (const char *queueName, const char *message, const char *data), (""), "(string queueName, string message, string data)"
+DefineEngineFunction( dispatchMessage, bool, (const char *queueName, const char *message, const char *data), (""), "(string queueName, string message, string data)"
 				"@brief Dispatch a message to a queue\n\n"
 				"@param queueName Queue to dispatch the message to\n"
 				"@param message Message to dispatch\n"
@@ -403,7 +403,7 @@ DefineConsoleFunction( dispatchMessage, bool, (const char *queueName, const char
    return Dispatcher::dispatchMessage(queueName, message, data);
 }
 
-DefineConsoleFunction( dispatchMessageObject, bool, (const char *queueName, const char *message), ("", ""), "(string queueName, string message)"
+DefineEngineFunction( dispatchMessageObject, bool, (const char *queueName, const char *message), ("", ""), "(string queueName, string message)"
 				"@brief Dispatch a message object to a queue\n\n"
 				"@param queueName Queue to dispatch the message to\n"
 				"@param message Message to dispatch\n"

Engine/source/util/sampler.cpp

@@ -394,7 +394,7 @@ SAMPLE_FUNC( const char* );
 //	Console Functions.
 //--------------------------------------------------------------------------------
 
-DefineConsoleFunction( beginSampling, void, (const char * location, const char * backend), ("CSV"), "(location, [backend]) -"
+DefineEngineFunction( beginSampling, void, (const char * location, const char * backend), ("CSV"), "(location, [backend]) -"
 				"@brief Takes a string informing the backend where to store "
 				"sample data and optionally a name of the specific logging "
 				"backend to use.  The default is the CSV backend. In most "
@@ -408,14 +408,14 @@ DefineConsoleFunction( beginSampling, void, (const char * location, const char *
    beginSampling( location, backend );
 }
 
-DefineConsoleFunction( stopSampling, void, (), , "()"
+DefineEngineFunction( stopSampling, void, (), , "()"
 				"@brief Stops the rendering sampler\n\n"
 				"@ingroup Rendering\n")
 {
    stopSampling();
 }
 
-DefineConsoleFunction( enableSamples, void, (const char * pattern, bool state), (true), "(pattern, [state]) -"
+DefineEngineFunction( enableSamples, void, (const char * pattern, bool state), (true), "(pattern, [state]) -"
 				"@brief Enable sampling for all keys that match the given name "
 				"pattern. Slashes are treated as separators.\n\n"
 				"@ingroup Rendering")