Merge pull request #2228 from lukaspj/fix-enginexmlexport

Make EngineAPI Export work properly

Engine/source/console/consoleObject.h

@@ -662,6 +662,29 @@ public:
       // Finally, do any class specific initialization...
       T::initPersistFields();
       T::consoleInit();
+
+      EnginePropertyTable::Property* props = new EnginePropertyTable::Property[sg_tempFieldList.size()];
+
+      for (int i = 0; i < sg_tempFieldList.size(); ++i)
+      {
+         EnginePropertyTable::Property prop;
+         prop.mDocString = sg_tempFieldList[i].pFieldDocs;
+         prop.mName = sg_tempFieldList[i].pFieldname;
+         prop.mNumElements = sg_tempFieldList[i].elementCount;
+         prop.mFlags = 0;
+         if (sg_tempFieldList[i].type == StartGroupFieldType)
+            prop.mFlags |= EnginePropertyGroupBegin;
+         if (sg_tempFieldList[i].type == EndGroupFieldType)
+            prop.mFlags |= EnginePropertyGroupEnd;
+         prop.mType = sg_tempFieldList[i].type;
+
+         props[i] = prop;
+      }
+
+      _smPropertyTable = EnginePropertyTable(sg_tempFieldList.size(), props);
+      smPropertyTable = _smPropertyTable;
+
+      const_cast<EngineTypeInfo*>(mTypeInfo)->mPropertyTable = &_smPropertyTable;
  
       // Let the base finish up.
       AbstractClassRep::init();

Engine/source/console/engineFunctions.h

@@ -25,6 +25,10 @@
 
 #include <tuple>
 
+#ifndef _FIXEDTUPLE_H_
+#include "fixedTuple.h"
+#endif
+
 #ifndef _ENGINEEXPORTS_H_
    #include "console/engineExports.h"
 #endif
@@ -94,6 +98,7 @@ template<typename ...ArgTs>
 struct _EngineFunctionDefaultArguments< void(ArgTs...) > : public EngineFunctionDefaultArguments
 {
    template<typename T> using DefVST = typename EngineTypeTraits<T>::DefaultArgumentValueStoreType;
+   fixed_tuple<DefVST<ArgTs>  ...> mFixedArgs;
    std::tuple<DefVST<ArgTs>  ...> mArgs;
 private:
    using SelfType = _EngineFunctionDefaultArguments< void(ArgTs...) >;
@@ -130,7 +135,9 @@ private:
 public:
    template<typename ...TailTs> _EngineFunctionDefaultArguments(TailTs ...tail)
    : EngineFunctionDefaultArguments({sizeof...(TailTs)}), mArgs(SelfType::tailInit(tail...))
-   {}
+   {
+      fixed_tuple_mutator<void(DefVST<ArgTs>...), void(DefVST<ArgTs>...)>::copy(mArgs, mFixedArgs);
+   }
 };
 
 #pragma pack( pop )

Engine/source/console/engineTypeInfo.h

@@ -231,6 +231,9 @@ class EnginePropertyTable
 
          /// Combination of EnginePropertyFlags.
          U32 mFlags;
+
+         /// Type-id of the property
+         U32 mType;
          
          /// Return the name of the property.
          const char* getName() const { return mName; }
@@ -255,6 +258,9 @@ class EnginePropertyTable
          
          ///
          bool hideInInspectors() const { return ( mFlags & EnginePropertyHideInInspectors ); }
+
+         /// Return the type-id of the property.
+         U32 getType() const { return mType; }
       };
       
    protected:

Engine/source/console/engineXMLExport.cpp

@@ -35,32 +35,32 @@
 /// actually having to access them directly in the DLL as native entities.
 
 
-static void exportScope( const EngineExportScope* scope, SimXMLDocument* xml, bool addNode = false );
+static void exportScope(const EngineExportScope* scope, SimXMLDocument* xml, bool addNode = false);
 
 
-static String getTypeName( const EngineTypeInfo* type )
+static String getTypeName(const EngineTypeInfo* type)
 {
-   if( !type )
+   if (!type)
    {
-      static String sVoid( "void" );
+      static String sVoid("void");
       return sVoid;
    }
-      
+
    return type->getFullyQualifiedExportName();
 }
 
-static const char* getDocString( const EngineExport* exportInfo )
+static const char* getDocString(const EngineExport* exportInfo)
 {
-   if( !exportInfo->getDocString() )
+   if (!exportInfo->getDocString())
       return "";
-   
+
    return exportInfo->getDocString();
 }
 
 template< typename T >
-inline T getArgValue( const EngineFunctionDefaultArguments* defaultArgs, U32 offset )
+inline T getArgValue(const EngineFunctionDefaultArguments* defaultArgs, U32 offset)
 {
-   return *reinterpret_cast< const T* >( defaultArgs->getArgs() + offset );
+   return *reinterpret_cast< const T* >(defaultArgs->getArgs() + offset);
 }
 
 
@@ -71,14 +71,14 @@ static const char* sExportFilterList[] =
    "Console", // Console namespace
 };
 
-static bool isExportFiltered( const EngineExport* exportInfo )
+static bool isExportFiltered(const EngineExport* exportInfo)
 {
    String qualifiedName = exportInfo->getFullyQualifiedExportName();
-   
-   for( U32 i = 0; i < ( sizeof( sExportFilterList ) / sizeof( sExportFilterList[ 0 ] ) ); ++ i )
-      if( qualifiedName.compare( sExportFilterList[ i ] ) == 0 )
+
+   for (U32 i = 0; i < (sizeof(sExportFilterList) / sizeof(sExportFilterList[0])); ++i)
+      if (qualifiedName.compare(sExportFilterList[i]) == 0)
          return true;
-         
+
    return false;
 }
 
@@ -90,248 +90,248 @@ static bool isExportFiltered( const EngineExport* exportInfo )
 //-----------------------------------------------------------------------------
 
 /// Helper to parse argument names out of a prototype string.
-static Vector< String > parseFunctionArgumentNames( const EngineFunctionInfo* function )
+static Vector< String > parseFunctionArgumentNames(const EngineFunctionInfo* function)
 {
    Vector< String > argNames;
-   
+
    const char* prototype = function->getPrototypeString();
-   if( !prototype )
+   if (!prototype)
       return argNames;
-      
-   const U32 prototypeLength = dStrlen( prototype );
-   const char* prototypeEnd = &prototype[ prototypeLength ];
+
+   const U32 prototypeLength = dStrlen(prototype);
+   const char* prototypeEnd = &prototype[prototypeLength];
    const char* ptr = prototypeEnd - 1;
-   
+
    // Search for right parenthesis.
-   while( ptr >= prototype && *ptr != ')' )
-      ptr --;
-      
-   if( ptr < prototype )
+   while (ptr >= prototype && *ptr != ')')
+      ptr--;
+
+   if (ptr < prototype)
       return argNames;
-   ptr --;
-   
-   while( ptr >= prototype && *ptr != '(' )
+   ptr--;
+
+   while (ptr >= prototype && *ptr != '(')
    {
       // Skip back over spaces.
-      
-      while( ptr >= prototype && dIsspace( *ptr ) )
-         ptr --;
-      if( ptr < prototype )
+
+      while (ptr >= prototype && dIsspace(*ptr))
+         ptr--;
+      if (ptr < prototype)
          return argNames;
-         
+
       // Parse out name.
-      
+
       const char* end = ptr + 1;
-      while( ptr > prototype && dIsalnum( *ptr ) )
-         ptr --;
+      while (ptr > prototype && dIsalnum(*ptr))
+         ptr--;
       const char* start = ptr + 1;
-               
+
       // Skip back over spaces.
 
-      while( ptr >= prototype && dIsspace( *ptr ) )
-         ptr --;
-         
+      while (ptr >= prototype && dIsspace(*ptr))
+         ptr--;
+
       // If we're sure we don't have just a type name without an
       // argument name, copy out the argument name name. 
 
-      if( ptr >= prototype && *ptr != ',' && *ptr != '(' && end > start )
-         argNames.push_front( String( start, end - start ) );
+      if (ptr >= prototype && *ptr != ',' && *ptr != '(' && end > start)
+         argNames.push_front(String(start, end - start));
       else
-         argNames.push_front( "" );
-      
+         argNames.push_front("");
+
       // Skip back to comma or opening parenthesis.
-      
+
       U32 parenNestingCount = 0;
-      while( ptr >= prototype )
+      while (ptr >= prototype)
       {
-         if( *ptr == ')' )
-            parenNestingCount ++;
-         else if( *ptr == '(' )
-            parenNestingCount --;
-         else if( *ptr == ',' && parenNestingCount == 0 )
+         if (*ptr == ')')
+            parenNestingCount++;
+         else if (*ptr == '(')
+            parenNestingCount--;
+         else if (*ptr == ',' && parenNestingCount == 0)
          {
-            ptr --;
+            ptr--;
             break;
          }
-         else if( *ptr == '(' && parenNestingCount == 0 )
+         else if (*ptr == '(' && parenNestingCount == 0)
             break;
-            
-         ptr --;
+
+         ptr--;
       }
    }
-   
+
    // Add 'this' parameter if this is a method.
-      
-   if( dStrncmp( prototype, "virtual ", sizeof( "virtual " ) - 1 ) == 0 )
-      argNames.push_front( "this" );
+
+   if (dStrncmp(prototype, "virtual ", sizeof("virtual ") - 1) == 0)
+      argNames.push_front("this");
 
    return argNames;
 }
 
 //-----------------------------------------------------------------------------
 
-static String getDefaultArgumentValue( const EngineFunctionInfo* function, const EngineTypeInfo* type, U32 offset )
+static String getDefaultArgumentValue(const EngineFunctionInfo* function, const EngineTypeInfo* type, U32 offset)
 {
    String value;
    const EngineFunctionDefaultArguments* defaultArgs = function->getDefaultArguments();
-   
-   switch( type->getTypeKind() )
+
+   switch (type->getTypeKind())
    {
-      case EngineTypeKindPrimitive:
-      {
-         #define PRIMTYPE( tp )                                               \
+   case EngineTypeKindPrimitive:
+   {
+#define PRIMTYPE( tp )                                               \
             if( TYPE< tp >() == type )                                        \
             {                                                                 \
                tp val = getArgValue< tp >( defaultArgs, offset );             \
                value = String::ToString( val );                               \
             }
-            
-         PRIMTYPE( bool );
-         PRIMTYPE( S8 );
-         PRIMTYPE( U8 );
-         PRIMTYPE( S32 );
-         PRIMTYPE( U32 );
-         PRIMTYPE( F32 );
-         PRIMTYPE( F64 );
-         
-         //TODO: for now we store string literals in ASCII; needs to be sorted out
-         if( TYPE< const char* >() == type )
-         {
-            const char* val = getArgValue< const char* >( defaultArgs, offset );
-            value = val;
-         }
-            
-         #undef PRIMTYPE
-         break;
-      }
-         
-      case EngineTypeKindEnum:
-      {
-         S32 val = getArgValue< S32 >( defaultArgs, offset );
-         AssertFatal( type->getEnumTable(), "engineXMLExport - Enum type without table!" );
-         
-         const EngineEnumTable& table = *( type->getEnumTable() );
-         const U32 numValues = table.getNumValues();
-         
-         for( U32 i = 0; i < numValues; ++ i )
-            if( table[ i ].getInt() == val )
-            {
-               value = table[ i ].getName();
-               break;
-            }
-               
-         break;
-      }
 
-      case EngineTypeKindBitfield:
-      {
-         S32 val = getArgValue< S32 >( defaultArgs, offset );
-         AssertFatal( type->getEnumTable(), "engineXMLExport - Bitfield type without table!" );
-         
-         const EngineEnumTable& table = *( type->getEnumTable() );
-         const U32 numValues = table.getNumValues();
-         
-         bool isFirst = true;
-         for( U32 i = 0; i < numValues; ++ i )
-            if( table[ i ].getInt() & val )
-            {
-               if( !isFirst )
-                  value += '|';
-                  
-               value = table[ i ].getName();
-               isFirst = false;
-            }
+      PRIMTYPE(bool);
+      PRIMTYPE(S8);
+      PRIMTYPE(U8);
+      PRIMTYPE(S32);
+      PRIMTYPE(U32);
+      PRIMTYPE(F32);
+      PRIMTYPE(F64);
 
-         break;
-      }
-      
-      case EngineTypeKindStruct:
+      //TODO: for now we store string literals in ASCII; needs to be sorted out
+      if (TYPE< const char* >() == type)
       {
-         //TODO: struct type default argument values
-         break;
-      }
-         
-      case EngineTypeKindClass:
-      case EngineTypeKindFunction:
-      {
-         // For these two kinds, we support "null" as the only valid
-         // default value.
-         
-         const void* ptr = getArgValue< const void* >( defaultArgs, offset );
-         if( !ptr )
-            value = "null";
-         break;
+         const char* val = reinterpret_cast<const char*>(defaultArgs->getArgs() + offset);
+         value = val;
       }
-      
-      default:
-         break;
+
+#undef PRIMTYPE
+      break;
    }
-   
+
+   case EngineTypeKindEnum:
+   {
+      S32 val = getArgValue< S32 >(defaultArgs, offset);
+      AssertFatal(type->getEnumTable(), "engineXMLExport - Enum type without table!");
+
+      const EngineEnumTable& table = *(type->getEnumTable());
+      const U32 numValues = table.getNumValues();
+
+      for (U32 i = 0; i < numValues; ++i)
+         if (table[i].getInt() == val)
+         {
+            value = table[i].getName();
+            break;
+         }
+
+      break;
+   }
+
+   case EngineTypeKindBitfield:
+   {
+      S32 val = getArgValue< S32 >(defaultArgs, offset);
+      AssertFatal(type->getEnumTable(), "engineXMLExport - Bitfield type without table!");
+
+      const EngineEnumTable& table = *(type->getEnumTable());
+      const U32 numValues = table.getNumValues();
+
+      bool isFirst = true;
+      for (U32 i = 0; i < numValues; ++i)
+         if (table[i].getInt() & val)
+         {
+            if (!isFirst)
+               value += '|';
+
+            value = table[i].getName();
+            isFirst = false;
+         }
+
+      break;
+   }
+
+   case EngineTypeKindStruct:
+   {
+      //TODO: struct type default argument values
+      break;
+   }
+
+   case EngineTypeKindClass:
+   case EngineTypeKindFunction:
+   {
+      // For these two kinds, we support "null" as the only valid
+      // default value.
+
+      const void* ptr = getArgValue< const void* >(defaultArgs, offset);
+      if (!ptr)
+         value = "null";
+      break;
+   }
+
+   default:
+      break;
+   }
+
    return value;
 }
 
 //-----------------------------------------------------------------------------
 
-static void exportFunction( const EngineFunctionInfo* function, SimXMLDocument* xml )
+static void exportFunction(const EngineFunctionInfo* function, SimXMLDocument* xml)
 {
-   if( isExportFiltered( function ) )
+   if (isExportFiltered(function))
       return;
-      
-   xml->pushNewElement( "EngineFunction" );
-      
-      xml->setAttribute( "name", function->getExportName() );
-      xml->setAttribute( "returnType", getTypeName( function->getReturnType() ) );
-      xml->setAttribute( "symbol", function->getBindingName() );
-      xml->setAttribute( "isCallback", function->isCallout() ? "1" : "0" );
-      xml->setAttribute( "isVariadic", function->getFunctionType()->isVariadic() ? "1" : "0" );
-      xml->setAttribute( "docs", getDocString( function ) );
-      
-      xml->pushNewElement( "arguments" );
-      
-         const U32 numArguments = function->getNumArguments();
-         const U32 numDefaultArguments = ( function->getDefaultArguments() ? function->getDefaultArguments()->mNumDefaultArgs : 0 );
-         const U32 firstDefaultArg = numArguments - numDefaultArguments;
-         
-         Vector< String > argumentNames = parseFunctionArgumentNames( function );
-         const U32 numArgumentNames = argumentNames.size();
-         
-         // Accumulated offset in function argument frame vector.
-         U32 argFrameOffset = 0;
-         
-         for( U32 i = 0; i < numArguments; ++ i )
-         {
-            xml->pushNewElement( "EngineFunctionArgument" );
-            const EngineTypeInfo* type = function->getArgumentType( i );
-            AssertFatal( type != NULL, "exportFunction - Argument cannot have type void!" );
-            
-            String argName;
-            if( i < numArgumentNames )
-               argName = argumentNames[ i ];
-               
-            xml->setAttribute( "name", argName );
-            xml->setAttribute( "type", getTypeName( type ) );
-            
-            if( i >= firstDefaultArg )
-            {
-               String defaultValue = getDefaultArgumentValue( function, type, argFrameOffset );
-               xml->setAttribute( "defaultValue", defaultValue );
-            }
 
-            xml->popElement();
-            
-            if( type->getTypeKind() == EngineTypeKindStruct )
-               argFrameOffset += type->getInstanceSize();
-            else
-               argFrameOffset += type->getValueSize();
-               
-            #ifdef _PACK_BUG_WORKAROUNDS
-            if( argFrameOffset % 4 > 0 )
-               argFrameOffset += 4 - ( argFrameOffset % 4 );
-            #endif
-         }
-         
+   xml->pushNewElement("EngineFunction");
+
+   xml->setAttribute("name", function->getExportName());
+   xml->setAttribute("returnType", getTypeName(function->getReturnType()));
+   xml->setAttribute("symbol", function->getBindingName());
+   xml->setAttribute("isCallback", function->isCallout() ? "1" : "0");
+   xml->setAttribute("isVariadic", function->getFunctionType()->isVariadic() ? "1" : "0");
+   xml->setAttribute("docs", getDocString(function));
+
+   xml->pushNewElement("arguments");
+
+   const U32 numArguments = function->getNumArguments();
+   const U32 numDefaultArguments = (function->getDefaultArguments() ? function->getDefaultArguments()->mNumDefaultArgs : 0);
+   const U32 firstDefaultArg = numArguments - numDefaultArguments;
+
+   Vector< String > argumentNames = parseFunctionArgumentNames(function);
+   const U32 numArgumentNames = argumentNames.size();
+
+   // Accumulated offset in function argument frame vector.
+   U32 argFrameOffset = 0;
+
+   for (U32 i = 0; i < numArguments; ++i)
+   {
+      xml->pushNewElement("EngineFunctionArgument");
+      const EngineTypeInfo* type = function->getArgumentType(i);
+      AssertFatal(type != NULL, "exportFunction - Argument cannot have type void!");
+
+      String argName;
+      if (i < numArgumentNames)
+         argName = argumentNames[i];
+
+      xml->setAttribute("name", argName);
+      xml->setAttribute("type", getTypeName(type));
+
+      if (i >= firstDefaultArg)
+      {
+         String defaultValue = getDefaultArgumentValue(function, type, argFrameOffset);
+         xml->setAttribute("defaultValue", defaultValue);
+      }
+
       xml->popElement();
-         
+
+      if (type->getTypeKind() == EngineTypeKindStruct)
+         argFrameOffset += type->getInstanceSize();
+      else
+         argFrameOffset += type->getValueSize();
+
+#ifdef _PACK_BUG_WORKAROUNDS
+      if (argFrameOffset % 4 > 0)
+         argFrameOffset += 4 - (argFrameOffset % 4);
+#endif
+   }
+
+   xml->popElement();
+
    xml->popElement();
 }
 
@@ -343,148 +343,172 @@ static void exportFunction( const EngineFunctionInfo* function, SimXMLDocument*
 
 //-----------------------------------------------------------------------------
 
-static void exportType( const EngineTypeInfo* type, SimXMLDocument* xml )
+static void exportType(const EngineTypeInfo* type, SimXMLDocument* xml)
 {
    // Don't export anonymous types.
-   if( !type->getTypeName()[ 0 ] )
+   if (!type->getTypeName()[0])
       return;
-      
-   if( isExportFiltered( type ) )
+
+   if (isExportFiltered(type))
       return;
-      
+
    const char* nodeName = NULL;
-   switch( type->getTypeKind() )
+   switch (type->getTypeKind())
    {
-      case EngineTypeKindPrimitive:
-         nodeName = "EnginePrimitiveType";
-         break;
-         
-      case EngineTypeKindEnum:
-         nodeName = "EngineEnumType";
-         break;
-         
-      case EngineTypeKindBitfield:
-         nodeName = "EngineBitfieldType";
-         break;
-         
-      case EngineTypeKindStruct:
-         nodeName = "EngineStructType";
-         break;
-         
-      case EngineTypeKindClass:
-         nodeName = "EngineClassType";
-         break;
-      
-      default:
-         return;
+   case EngineTypeKindPrimitive:
+      nodeName = "EnginePrimitiveType";
+      break;
+
+   case EngineTypeKindEnum:
+      nodeName = "EngineEnumType";
+      break;
+
+   case EngineTypeKindBitfield:
+      nodeName = "EngineBitfieldType";
+      break;
+
+   case EngineTypeKindStruct:
+      nodeName = "EngineStructType";
+      break;
+
+   case EngineTypeKindClass:
+      nodeName = "EngineClassType";
+      break;
+
+   default:
+      return;
    }
-   
-   xml->pushNewElement( nodeName );
-
-      xml->setAttribute( "name", type->getTypeName() );
-      xml->setAttribute( "size", String::ToString( type->getInstanceSize() ) );
-      xml->setAttribute( "isAbstract", type->isAbstract() ? "1" : "0" );
-      xml->setAttribute( "isInstantiable", type->isInstantiable() ? "1" : "0" );
-      xml->setAttribute( "isDisposable", type->isDisposable() ? "1" : "0" );
-      xml->setAttribute( "isSingleton", type->isSingleton() ? "1" : "0" );
-      xml->setAttribute( "docs", getDocString( type ) );
-      
-      if( type->getSuperType() )
-         xml->setAttribute( "superType", getTypeName( type->getSuperType() ) );
-      
-      if( type->getEnumTable() )
+
+   xml->pushNewElement(nodeName);
+
+   xml->setAttribute("name", type->getTypeName());
+   xml->setAttribute("size", String::ToString(type->getInstanceSize()));
+   xml->setAttribute("isAbstract", type->isAbstract() ? "1" : "0");
+   xml->setAttribute("isInstantiable", type->isInstantiable() ? "1" : "0");
+   xml->setAttribute("isDisposable", type->isDisposable() ? "1" : "0");
+   xml->setAttribute("isSingleton", type->isSingleton() ? "1" : "0");
+   xml->setAttribute("docs", getDocString(type));
+
+   if (type->getSuperType())
+      xml->setAttribute("superType", getTypeName(type->getSuperType()));
+
+   if (type->getEnumTable())
+   {
+      xml->pushNewElement("enums");
+
+      const EngineEnumTable& table = *(type->getEnumTable());
+      const U32 numValues = table.getNumValues();
+
+      for (U32 i = 0; i < numValues; ++i)
       {
-         xml->pushNewElement( "enums" );
-         
-            const EngineEnumTable& table = *( type->getEnumTable() );
-            const U32 numValues = table.getNumValues();
-            
-            for( U32 i = 0; i < numValues; ++ i )
-            {
-               xml->pushNewElement( "EngineEnum" );
-               
-                  xml->setAttribute( "name", table[ i ].getName() );
-                  xml->setAttribute( "value", String::ToString( table[ i ].getInt() ) );
-                  xml->setAttribute( "docs", table[ i ].getDocString() ? table[ i ].getDocString() : "" );
-                  
-               xml->popElement();
-            }
-            
+         xml->pushNewElement("EngineEnum");
+
+         xml->setAttribute("name", table[i].getName());
+         xml->setAttribute("value", String::ToString(table[i].getInt()));
+         xml->setAttribute("docs", table[i].getDocString() ? table[i].getDocString() : "");
+
          xml->popElement();
       }
-      else if( type->getFieldTable() )
+
+      xml->popElement();
+   }
+   else if (type->getFieldTable())
+   {
+      xml->pushNewElement("fields");
+
+      const EngineFieldTable& table = *(type->getFieldTable());
+      const U32 numFields = table.getNumFields();
+
+      for (U32 i = 0; i < numFields; ++i)
       {
-         xml->pushNewElement( "fields" );
-         
-            const EngineFieldTable& table = *( type->getFieldTable() );
-            const U32 numFields = table.getNumFields();
-            
-            for( U32 i = 0; i < numFields; ++ i )
-            {
-               const EngineFieldTable::Field& field = table[ i ];
-               
-               xml->pushNewElement( "EngineField" );
-               
-                  xml->setAttribute( "name", field.getName() );
-                  xml->setAttribute( "type", getTypeName( field.getType() ) );
-                  xml->setAttribute( "offset", String::ToString( field.getOffset() ) );
-                  xml->setAttribute( "indexedSize", String::ToString( field.getNumElements() ) );
-                  xml->setAttribute( "docs", field.getDocString() ? field.getDocString() : "" );
-               
-               xml->popElement();
-            }
-         
+         const EngineFieldTable::Field& field = table[i];
+
+         xml->pushNewElement("EngineField");
+
+         xml->setAttribute("name", field.getName());
+         xml->setAttribute("type", getTypeName(field.getType()));
+         xml->setAttribute("offset", String::ToString(field.getOffset()));
+         xml->setAttribute("indexedSize", String::ToString(field.getNumElements()));
+         xml->setAttribute("docs", field.getDocString() ? field.getDocString() : "");
+
          xml->popElement();
       }
-      else if( type->getPropertyTable() )
+
+      xml->popElement();
+   }
+   else if (type->getPropertyTable())
+   {
+      xml->pushNewElement("properties");
+
+      const EnginePropertyTable& table = *(type->getPropertyTable());
+      const U32 numProperties = table.getNumProperties();
+      U32 groupNestingDepth = 0;
+
+      for (U32 i = 0; i < numProperties; ++i)
       {
-         xml->pushNewElement( "properties" );
-         
-            const EnginePropertyTable& table = *( type->getPropertyTable() );
-            const U32 numProperties = table.getNumProperties();
-            U32 groupNestingDepth = 0;
-            
-            for( U32 i = 0; i < numProperties; ++ i )
+         const EnginePropertyTable::Property& property = table[i];
+
+         if (property.isGroupBegin())
+         {
+            groupNestingDepth++;
+            xml->pushNewElement("EnginePropertyGroup");
+
+            xml->setAttribute("name", property.getName());
+            xml->setAttribute("indexedSize", String::ToString(property.getNumElements()));
+            xml->setAttribute("docs", property.getDocString() ? property.getDocString() : "");
+
+            xml->pushNewElement("properties");
+         }
+         else if (property.isGroupEnd())
+         {
+            groupNestingDepth--;
+            xml->popElement();
+            xml->popElement();
+         }
+         else
+         {
+            if (property.getType() == AbstractClassRep::StartArrayFieldType
+               || property.getType() == AbstractClassRep::EndArrayFieldType) {
+               continue;
+            }
+            xml->pushNewElement("EngineProperty");
+
+            xml->setAttribute("name", property.getName());
+            xml->setAttribute("indexedSize", String::ToString(property.getNumElements()));
+            xml->setAttribute("isConstant", property.isConstant() ? "1" : "0");
+            xml->setAttribute("isTransient", property.isTransient() ? "1" : "0");
+            xml->setAttribute("isVisible", property.hideInInspectors() ? "0" : "1");
+            xml->setAttribute("docs", property.getDocString() ? property.getDocString() : "");
+
+
+            const bool isDeprecated = (property.getType() == AbstractClassRep::DeprecatedFieldType);
+
+            if (isDeprecated)
             {
-               const EnginePropertyTable::Property& property = table[ i ];
-               
-               if( property.isGroupBegin() )
-               {
-                  groupNestingDepth ++;
-                  xml->pushNewElement( "EnginePropertyGroup" );
-                  
-                     xml->setAttribute( "name", property.getName() );
-                     xml->setAttribute( "indexedSize", String::ToString( property.getNumElements() ) );
-                     xml->setAttribute( "docs", property.getDocString() ? property.getDocString() : "" );
-                     
-                     xml->pushNewElement( "properties" );
-               }
-               else if( property.isGroupEnd() )
+               xml->setAttribute("type", "deprecated");
+            }
+            else
+            {
+               ConsoleBaseType *cbt = ConsoleBaseType::getType(property.getType());
+               if (cbt != NULL)
                {
-                  groupNestingDepth --;
-                  xml->popElement();
-                  xml->popElement();
+                  xml->setAttribute("type", cbt->getTypeClassName());
                }
                else
                {
-                  xml->pushNewElement( "EngineProperty" );
-                  
-                     xml->setAttribute( "name", property.getName() );
-                     xml->setAttribute( "indexedSize", String::ToString( property.getNumElements() ) );
-                     xml->setAttribute( "isConstant", property.isConstant() ? "1" : "0" );
-                     xml->setAttribute( "isTransient", property.isTransient() ? "1" : "0" );
-                     xml->setAttribute( "isVisible", property.hideInInspectors() ? "0" : "1" );
-                     xml->setAttribute( "docs", property.getDocString() ? property.getDocString() : "" );
-                  
-                  xml->popElement();
+                  xml->setAttribute("type", "unknown");
                }
             }
-         
-         AssertFatal( !groupNestingDepth, "exportType - Property group nesting mismatch!" );
-         xml->popElement();
-      }      
-      exportScope( type, xml );
-      
+
+            xml->popElement();
+         }
+      }
+
+      AssertFatal(!groupNestingDepth, "exportType - Property group nesting mismatch!");
+      xml->popElement();
+   }
+   exportScope(type, xml);
+
    xml->popElement();
 }
 
@@ -496,63 +520,63 @@ static void exportType( const EngineTypeInfo* type, SimXMLDocument* xml )
 
 //-----------------------------------------------------------------------------
 
-static void exportScope( const EngineExportScope* scope, SimXMLDocument* xml, bool addNode )
+static void exportScope(const EngineExportScope* scope, SimXMLDocument* xml, bool addNode)
 {
-   if( addNode )
+   if (addNode)
    {
-      if( isExportFiltered( scope ) )
+      if (isExportFiltered(scope))
          return;
-         
-      xml->pushNewElement( "EngineExportScope" );
-      
-         xml->setAttribute( "name", scope->getExportName() );
-         xml->setAttribute( "docs", getDocString( scope ) );
+
+      xml->pushNewElement("EngineExportScope");
+
+      xml->setAttribute("name", scope->getExportName());
+      xml->setAttribute("docs", getDocString(scope));
    }
 
    // Dump all contained exports.
-   
-   xml->pushNewElement( "exports" );
-   
-      for( const EngineExport* exportInfo = scope->getExports(); exportInfo != NULL; exportInfo = exportInfo->getNextExport() )
+
+   xml->pushNewElement("exports");
+
+   for (const EngineExport* exportInfo = scope->getExports(); exportInfo != NULL; exportInfo = exportInfo->getNextExport())
+   {
+      switch (exportInfo->getExportKind())
       {
-         switch( exportInfo->getExportKind() )
-         {
-            case EngineExportKindScope:
-               exportScope( static_cast< const EngineExportScope* >( exportInfo ), xml, true );
-               break;
-               
-            case EngineExportKindFunction:
-               exportFunction( static_cast< const EngineFunctionInfo* >( exportInfo ), xml );
-               break;
-               
-            case EngineExportKindType:
-               exportType( static_cast< const EngineTypeInfo* >( exportInfo ), xml );
-               break;
-               
-            default:
-               break;
-         }
+      case EngineExportKindScope:
+         exportScope(static_cast< const EngineExportScope* >(exportInfo), xml, true);
+         break;
+
+      case EngineExportKindFunction:
+         exportFunction(static_cast< const EngineFunctionInfo* >(exportInfo), xml);
+         break;
+
+      case EngineExportKindType:
+         exportType(static_cast< const EngineTypeInfo* >(exportInfo), xml);
+         break;
+
+      default:
+         break;
       }
-      
+   }
+
    xml->popElement();
-   
-   if( addNode )
+
+   if (addNode)
       xml->popElement();
 }
 
 //-----------------------------------------------------------------------------
 
-DefineEngineFunction( exportEngineAPIToXML, SimXMLDocument*, (),,
+DefineEngineFunction(exportEngineAPIToXML, SimXMLDocument*, (), ,
    "Create a XML document containing a dump of the entire exported engine API.\n\n"
    "@return A SimXMLDocument containing a dump of the engine's export information or NULL if the operation failed.\n\n"
-   "@ingroup Console" )
+   "@ingroup Console")
 {
    SimXMLDocument* xml = new SimXMLDocument;
    xml->registerObject();
-   Sim::getRootGroup()->addObject( xml );
+   Sim::getRootGroup()->addObject(xml);
    xml->addHeader();
-   
-   exportScope( EngineExportScope::getGlobalScope(), xml, true );
-   
+
+   exportScope(EngineExportScope::getGlobalScope(), xml, true);
+
    return xml;
-}
+}

Engine/source/console/fixedTuple.h

@@ -0,0 +1,153 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2012 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#ifndef _FIXEDTUPLE_H_
+#define _FIXEDTUPLE_H_
+/// @name Fixed-layout tuple definition
+/// These structs and templates serve as a way to pass arguments from external 
+/// applications and into the T3D console system.
+/// They work as std::tuple, but they ensure a standardized fixed memory 
+/// layout. Allowing for unmanaged calls with these tuples as the parameter 
+/// lists.
+///
+/// The implementation is from a SO solution:
+/// https://codereview.stackexchange.com/a/52279
+/// As out use-case is pretty simple, this code could probably be simplified by 
+/// stripping out a lot of extra functionality. But eh.
+///
+/// @{
+
+template <typename ...Ts>
+struct fixed_tuple;
+
+template <typename T, typename ...Ts>
+struct fixed_tuple<T, Ts...>
+{
+   T first;
+   fixed_tuple<Ts...> rest;
+
+   fixed_tuple() = default;
+   template <class U, class...Us, class = typename ::std::enable_if<!::std::is_base_of<fixed_tuple, typename ::std::decay<U>::type>::value>::type>
+   fixed_tuple(U&& u, Us&&...tail) :
+      first(::std::forward<U>(u)),
+      rest(::std::forward<Us>(tail)...) {}
+};
+
+template <typename T>
+struct fixed_tuple<T>
+{
+   T first;
+
+   fixed_tuple() = default;
+   template <class U, class = typename ::std::enable_if<!::std::is_base_of<fixed_tuple, typename ::std::decay<U>::type>::value>::type>
+   fixed_tuple(U&& u) :
+      first(::std::forward<U>(u)) {}
+};
+
+template <>
+struct fixed_tuple<> {};
+
+
+template < ::std::size_t i, class T>
+struct fixed_tuple_element;
+
+template < ::std::size_t i, class T, class... Ts>
+struct fixed_tuple_element<i, fixed_tuple<T, Ts...> >
+   : fixed_tuple_element<i - 1, fixed_tuple<Ts...> >
+{};
+
+template <class T, class... Ts>
+struct fixed_tuple_element<0, fixed_tuple<T, Ts...> >
+{
+   using type = T;
+};
+
+template < ::std::size_t i>
+struct fixed_tuple_accessor
+{
+   template <class... Ts>
+   static inline typename fixed_tuple_element<i, fixed_tuple<Ts...> >::type & get(fixed_tuple<Ts...> & t)
+   {
+      return fixed_tuple_accessor<i - 1>::get(t.rest);
+   }
+
+   template <class... Ts>
+   static inline const typename fixed_tuple_element<i, fixed_tuple<Ts...> >::type & get(const fixed_tuple<Ts...> & t)
+   {
+      return fixed_tuple_accessor<i - 1>::get(t.rest);
+   }
+};
+
+template <>
+struct fixed_tuple_accessor<0>
+{
+   template <class... Ts>
+   static inline typename fixed_tuple_element<0, fixed_tuple<Ts...> >::type & get(fixed_tuple<Ts...> & t)
+   {
+      return t.first;
+   }
+
+   template <class... Ts>
+   static inline const typename fixed_tuple_element<0, fixed_tuple<Ts...> >::type & get(const fixed_tuple<Ts...> & t)
+   {
+      return t.first;
+   }
+};
+
+template< typename T1, typename T2 >
+struct fixed_tuple_mutator {};
+
+template<typename... Tdest, typename... Tsrc>
+struct fixed_tuple_mutator<void(Tdest...), void(Tsrc...)>
+{
+   template<std::size_t I = 0>
+   static inline typename std::enable_if<I == sizeof...(Tsrc), void>::type
+      copy_r_t_l(fixed_tuple<Tsrc...>& src, fixed_tuple<Tdest...>& dest)
+   { }
+
+   template<std::size_t I = 0>
+   static inline typename std::enable_if<I < sizeof...(Tsrc), void>::type
+      copy_r_t_l(fixed_tuple<Tsrc...>& src, fixed_tuple<Tdest...>& dest)
+   {
+      fixed_tuple_accessor<I + (sizeof...(Tdest)-sizeof...(Tsrc))>::get(dest) = fixed_tuple_accessor<I>::get(src);
+      copy_r_t_l<I + 1>(src, dest);
+   }
+
+   template<std::size_t I = 0>
+   static inline typename std::enable_if<I == sizeof...(Tsrc), void>::type
+      copy(std::tuple<Tsrc...>& src, fixed_tuple<Tdest...>& dest)
+   { }
+
+   template<std::size_t I = 0>
+   static inline typename std::enable_if<I < sizeof...(Tsrc), void>::type
+      copy(std::tuple<Tsrc...>& src, fixed_tuple<Tdest...>& dest)
+   {
+      fixed_tuple_accessor<I>::get(dest) = std::get<I>(src);
+      copy<I + 1>(src, dest);
+   }
+};
+
+
+/// @}
+
+
+#endif // !_FIXEDTUPLE_H_