Fix for enumerations in Lua scripts so that passing enums from C++ to Lua works properly.

Adds support for key, mouse, touch, and gamepad event callbacks in Lua scripts.
Adds support for calling Game::exit() from Lua scripts.

gameplay-luagen/TODO.txt

@@ -10,8 +10,6 @@ Normal Priority List:
 - Add support for object arrays (i.e. VertexElement*).
 - Add "@script{create}" to the appropriate gameplay functions.
 - Fix memory leaks in gameplay-luagen and in generated code.
-
-- Add support for touch/key/mouse event callbacks.
 - Add support for listener callbacks.
 
 Low Priority List:

gameplay-luagen/src/FunctionBinding.cpp

@@ -894,7 +894,7 @@ static inline void outputReturnValue(ostream& o, const FunctionBinding& b, int i
         o << "lua_pushnumber(state, result);\n";
         break;
     case FunctionBinding::Param::TYPE_ENUM:
-        o << "lua_pushstring(state, lua_stringFromEnum_" << Generator::getInstance()->getUniqueNameFromRef(b.returnParam.info) << "(result).c_str());\n";
+        o << "lua_pushstring(state, lua_stringFromEnum_" << Generator::getInstance()->getUniqueNameFromRef(b.returnParam.info) << "(result));\n";
         break;
     case FunctionBinding::Param::TYPE_STRING:
         if (b.returnParam.info == "string")

gameplay-luagen/src/Generator.cpp

@@ -1341,9 +1341,10 @@ void Generator::generateBindings()
                 for (map<string, EnumBinding>::iterator iter = _enums.begin(); iter != _enums.end(); iter++)
                 {
                     global << iter->first << " lua_enumFromString_" << getUniqueName(iter->first) << "(const char* s);\n";
-                    global << "std::string lua_stringFromEnum_" << getUniqueName(iter->first) << "(" << iter->first << " e);\n";
+                    global << "const char* lua_stringFromEnum_" << getUniqueName(iter->first) << "(" << iter->first << " e);\n";
                 }
                 global << "\n";
+                global << "const char* lua_stringFromEnumGlobal(std::string& enumname, unsigned int value);\n\n";
             }
             
             // Write out the signature of the function used to register the global functions with Lua.
@@ -1437,6 +1438,7 @@ void Generator::generateBindings()
             }
 
             // Write out the enum conversion functions.
+            global << "static const char* enumStringEmpty = \"\";\n\n";
             for (map<string, EnumBinding>::iterator iter = _enums.begin(); iter != _enums.end(); iter++)
             {
                 // Build the scope string if applicable.
@@ -1449,6 +1451,14 @@ void Generator::generateBindings()
                     }
                 }
 
+                // Write out the string constants that correspond to the enumeration values.
+                for (unsigned int i = 0; i < iter->second.values.size(); i++)
+                {
+                    global << "static const char* luaEnumString_" << getUniqueName(iter->first) << "_";
+                    global << iter->second.values[i] << " = \"" << iter->second.values[i] << "\";\n";
+                }
+                global << "\n";
+
                 global << iter->first << " lua_enumFromString_" << getUniqueName(iter->first) << "(const char* s)\n";
                 global << "{\n";
                 
@@ -1456,7 +1466,7 @@ void Generator::generateBindings()
                 {
                     global << "    ";
                         
-                    global << "if (strcmp(s, \"" << iter->second.values[i] << "\") == 0)\n";
+                    global << "if (strcmp(s, luaEnumString_" << getUniqueName(iter->first) << "_" << iter->second.values[i] << ") == 0)\n";
                     global << "        return ";
                     if (scope.size() > 0)
                         global << scope;
@@ -1474,9 +1484,10 @@ void Generator::generateBindings()
 
                 global << "}\n\n";
 
-                global << "std::string lua_stringFromEnum_" << getUniqueName(iter->first) << "(" << iter->first << " e)\n";
+                global << "const char* lua_stringFromEnum_" << getUniqueName(iter->first) << "(" << iter->first << " e)\n";
                 global << "{\n";
-                
+
+                // Write out the enum-to-string conversion code.
                 for (unsigned int i = 0; i < iter->second.values.size(); i++)
                 {
                     global << "    ";
@@ -1485,18 +1496,32 @@ void Generator::generateBindings()
                     if (scope.size() > 0)
                         global << scope;
                     global << iter->second.values[i] << ")\n";
-                    global << "        return std::string(\"" << iter->second.values[i] << "\");\n";
+                    global << "        return luaEnumString_" << getUniqueName(iter->first) << "_" << iter->second.values[i] << ";\n";
 
                     if (i == iter->second.values.size() - 1)
                     {
                         global << "    GP_ERROR(\"Invalid enumeration value '%d' for enumeration " << iter->first << ".\", e);\n";
-                        global << "    return std::string();\n";
+                        global << "    return enumStringEmpty;\n";
                     }
                 }
 
                 global << "}\n\n";
             }
 
+            // Write out the global enum conversion function (used to pass enums from C++ to Lua).
+            global << "const char* lua_stringFromEnumGlobal(std::string& enumname, unsigned int value)\n";
+            global << "{\n";
+            for (map<string, EnumBinding>::iterator iter = _enums.begin(); iter != _enums.end(); iter++)
+            {
+                global << "    if (enumname == \"";
+                global << iter->first << "\")\n";
+                global << "        return lua_stringFromEnum_" << getUniqueName(iter->first) << "((" << iter->first << ")value);\n";
+            }
+            global << "\n";
+            global << "    GP_ERROR(\"Unrecognized enumeration type '%s'.\", enumname.c_str());\n";
+            global << "    return enumStringEmpty;\n";
+            global << "}\n\n";
+
             if (bindingNS)
                 global << "}\n";
             global.close();

gameplay/src/Game.cpp

@@ -30,6 +30,9 @@ Game::Game()
 
 Game::~Game()
 {
+    _scriptController->finalize();
+    SAFE_DELETE(_scriptController);
+
     // Do not call any virtual functions from the destructor.
     // Finalization is done from outside this class.
     SAFE_DELETE(_timeEvents);
@@ -116,41 +119,8 @@ bool Game::startup()
             const char* name;
             while ((name = scripts->getNextProperty()) != NULL)
             {
-                if (strcmp(name, "INITIALIZE") == 0)
-                {
-                    std::string url = scripts->getString();
-                    std::string file;
-                    std::string id;
-                    splitURL(url, &file, &id);
-
-                    if (file.size() <= 0 || id.size() <= 0)
-                    {
-                        GP_ERROR("Invalid INITIALIZE script callback function '%s'.", url.c_str());
-                    }
-                    else
-                    {
-                        _scriptController->loadScript(file.c_str());
-                        _scriptController->registerCallback(ScriptController::INITIALIZE, id);
-                    }
-                }
-                else if (strcmp(name, "UPDATE") == 0)
-                {
-                    std::string url = scripts->getString();
-                    std::string file;
-                    std::string id;
-                    splitURL(url, &file, &id);
-
-                    if (file.size() <= 0 || id.size() <= 0)
-                    {
-                        GP_ERROR("Invalid UPDATE script callback function '%s'.", url.c_str());
-                    }
-                    else
-                    {
-                        _scriptController->loadScript(file.c_str());
-                        _scriptController->registerCallback(ScriptController::UPDATE, id);
-                    }
-                }
-                else if (strcmp(name, "RENDER") == 0)
+                ScriptController::ScriptCallback callback = toCallback(name);
+                if (callback != ScriptController::INVALID_CALLBACK)
                 {
                     std::string url = scripts->getString();
                     std::string file;
@@ -159,29 +129,12 @@ bool Game::startup()
 
                     if (file.size() <= 0 || id.size() <= 0)
                     {
-                        GP_ERROR("Invalid RENDER script callback function '%s'.", url.c_str());
+                        GP_ERROR("Invalid %s script callback function '%s'.", name, url.c_str());
                     }
                     else
                     {
                         _scriptController->loadScript(file.c_str());
-                        _scriptController->registerCallback(ScriptController::RENDER, id);
-                    }
-                }
-                else if (strcmp(name, "FINALIZE") == 0)
-                {
-                    std::string url = scripts->getString();
-                    std::string file;
-                    std::string id;
-                    splitURL(url, &file, &id);
-
-                    if (file.size() <= 0 || id.size() <= 0)
-                    {
-                        GP_ERROR("Invalid FINALIZE script callback function '%s'.", url.c_str());
-                    }
-                    else
-                    {
-                        _scriptController->loadScript(file.c_str());
-                        _scriptController->registerCallback(ScriptController::FINALIZE, id);
+                        _scriptController->registerCallback(callback, id);
                     }
                 }
                 else
@@ -227,8 +180,8 @@ void Game::shutdown()
         _physicsController->finalize();
         SAFE_DELETE(_physicsController);
 
-        _scriptController->finalize();
-        SAFE_DELETE(_scriptController);
+        // Note: we do not clean up the script controller here
+        // because users can call Game::exit() from a script.
 
         SAFE_DELETE(_audioListener);
 
@@ -532,4 +485,26 @@ Gamepad* Game::createGamepad(const char* gamepadId, const char* gamepadFormPath)
     return gamepad;
 }
 
+ScriptController::ScriptCallback Game::toCallback(const char* name)
+{
+    if (strcmp(name, "INITIALIZE") == 0)
+        return ScriptController::INITIALIZE;
+    else if (strcmp(name, "UPDATE") == 0)
+        return ScriptController::UPDATE;
+    else if (strcmp(name, "RENDER") == 0)
+        return ScriptController::RENDER;
+    else if (strcmp(name, "FINALIZE") == 0)
+        return ScriptController::FINALIZE;
+    else if (strcmp(name, "KEY_EVENT") == 0)
+        return ScriptController::KEY_EVENT;
+    else if (strcmp(name, "TOUCH_EVENT") == 0)
+        return ScriptController::TOUCH_EVENT;
+    else if (strcmp(name, "MOUSE_EVENT") == 0)
+        return ScriptController::MOUSE_EVENT;
+    else if (strcmp(name, "GAMEPAD_EVENT") == 0)
+        return ScriptController::GAMEPAD_EVENT;
+    else
+        return ScriptController::INVALID_CALLBACK;
+}
+
 }

gameplay/src/Game.h

@@ -489,6 +489,15 @@ private:
      */
     Gamepad* createGamepad(const char* gamepadId, const char* gamepadFormPath);
 
+    /**
+     * Converts the given string to a valid script callback enumeration value
+     * or to ScriptController::INVALID_CALLBACK if there is no valid conversion.
+     * 
+     * @param name The name of the callback.
+     * @return The corresponding callback enumeration value.
+     */
+    static ScriptController::ScriptCallback toCallback(const char* name);
+
     bool _initialized;                          // If game has initialized yet.
     State _state;                               // The game state.
     static double _pausedTimeLast;              // The last time paused.

gameplay/src/PlatformAndroid.cpp

@@ -963,13 +963,19 @@ void Platform::displayKeyboard(bool display)
 void Platform::touchEventInternal(Touch::TouchEvent evt, int x, int y, unsigned int contactIndex)
 {
     if (!Form::touchEventInternal(evt, x, y, contactIndex))
+    {
         Game::getInstance()->touchEvent(evt, x, y, contactIndex);
+        ScriptController::getInstance()->touchEvent(evt, x, y, contactIndex);
+    }
 }
 
 void Platform::keyEventInternal(Keyboard::KeyEvent evt, int key)
 {
     if (!Form::keyEventInternal(evt, key))
+    {
         Game::getInstance()->keyEvent(evt, key);
+        ScriptController::getInstance()->keyEvent(evt, key);
+    }
 }
 
 bool Platform::mouseEventInternal(Mouse::MouseEvent evt, int x, int y, int wheelDelta)
@@ -978,9 +984,13 @@ bool Platform::mouseEventInternal(Mouse::MouseEvent evt, int x, int y, int wheel
     {
         return true;
     }
+    else if (Game::getInstance()->mouseEvent(evt, x, y, wheelDelta))
+    {
+        return true;
+    }
     else
     {
-        return Game::getInstance()->mouseEvent(evt, x, y, wheelDelta);
+        return ScriptController::getInstance()->mouseEvent(evt, x, y, wheelDelta);
     }
 }
 

gameplay/src/PlatformMacOSX.mm

@@ -842,13 +842,19 @@ void Platform::displayKeyboard(bool display)
 void Platform::touchEventInternal(Touch::TouchEvent evt, int x, int y, unsigned int contactIndex)
 {
     if (!Form::touchEventInternal(evt, x, y, contactIndex))
+    {
         Game::getInstance()->touchEvent(evt, x, y, contactIndex);
+        ScriptController::getInstance()->touchEvent(evt, x, y, contactIndex);
+    }
 }
     
 void Platform::keyEventInternal(Keyboard::KeyEvent evt, int key)
 {
     if (!Form::keyEventInternal(evt, key))
+    {
         Game::getInstance()->keyEvent(evt, key);
+        ScriptController::getInstance()->keyEvent(evt, key);
+    }
 }
 
 bool Platform::mouseEventInternal(Mouse::MouseEvent evt, int x, int y, int wheelDelta)
@@ -857,9 +863,13 @@ bool Platform::mouseEventInternal(Mouse::MouseEvent evt, int x, int y, int wheel
     {
         return true;
     }
+    else if (Game::getInstance()->mouseEvent(evt, x, y, wheelDelta))
+    {
+        return true;
+    }
     else
     {
-        return Game::getInstance()->mouseEvent(evt, x, y, wheelDelta);
+        return ScriptController::getInstance()->mouseEvent(evt, x, y, wheelDelta);
     }
 }
 

gameplay/src/PlatformQNX.cpp

@@ -1159,13 +1159,19 @@ void Platform::displayKeyboard(bool display)
 void Platform::touchEventInternal(Touch::TouchEvent evt, int x, int y, unsigned int contactIndex)
 {
     if (!Form::touchEventInternal(evt, x, y, contactIndex))
+    {
         Game::getInstance()->touchEvent(evt, x, y, contactIndex);
+        ScriptController::getInstance()->touchEvent(evt, x, y, contactIndex);
+    }
 }
 
 void Platform::keyEventInternal(Keyboard::KeyEvent evt, int key)
 {
     if (!Form::keyEventInternal(evt, key))
+    {
         Game::getInstance()->keyEvent(evt, key);
+        ScriptController::getInstance()->keyEvent(evt, key);
+    }
 }
 
 bool Platform::mouseEventInternal(Mouse::MouseEvent evt, int x, int y, int wheelDelta)
@@ -1174,9 +1180,13 @@ bool Platform::mouseEventInternal(Mouse::MouseEvent evt, int x, int y, int wheel
     {
         return true;
     }
+    else if (Game::getInstance()->mouseEvent(evt, x, y, wheelDelta))
+    {
+        return true;
+    }
     else
     {
-        return Game::getInstance()->mouseEvent(evt, x, y, wheelDelta);
+        return ScriptController::getInstance()->mouseEvent(evt, x, y, wheelDelta);
     }
 }
 

gameplay/src/PlatformWin32.cpp

@@ -844,13 +844,19 @@ void Platform::displayKeyboard(bool display)
 void Platform::touchEventInternal(Touch::TouchEvent evt, int x, int y, unsigned int contactIndex)
 {
     if (!Form::touchEventInternal(evt, x, y, contactIndex))
+    {
         Game::getInstance()->touchEvent(evt, x, y, contactIndex);
+        ScriptController::getInstance()->touchEvent(evt, x, y, contactIndex);
+    }
 }
 
 void Platform::keyEventInternal(Keyboard::KeyEvent evt, int key)
 {
     if (!Form::keyEventInternal(evt, key))
+    {
         Game::getInstance()->keyEvent(evt, key);
+        ScriptController::getInstance()->keyEvent(evt, key);
+    }
 }
 
 bool Platform::mouseEventInternal(Mouse::MouseEvent evt, int x, int y, int wheelDelta)
@@ -859,9 +865,13 @@ bool Platform::mouseEventInternal(Mouse::MouseEvent evt, int x, int y, int wheel
     {
         return true;
     }
+    else if (Game::getInstance()->mouseEvent(evt, x, y, wheelDelta))
+    {
+        return true;
+    }
     else
     {
-        return Game::getInstance()->mouseEvent(evt, x, y, wheelDelta);
+        return ScriptController::getInstance()->mouseEvent(evt, x, y, wheelDelta);
     }
 }
 

gameplay/src/PlatformiOS.mm

@@ -952,13 +952,19 @@ void Platform::displayKeyboard(bool display)
 void Platform::touchEventInternal(Touch::TouchEvent evt, int x, int y, unsigned int contactIndex)
 {
     if (!Form::touchEventInternal(evt, x, y, contactIndex))
-        Game::getInstance()->touchEvent(evt, x, y, contactIndex);
+    {
+        Game::getInstance()->touchEvent(evt, x, y, contactIndex);
+        ScriptController::getInstance()->touchEvent(evt, x, y, contactIndex);
+    }
 }
     
 void Platform::keyEventInternal(Keyboard::KeyEvent evt, int key)
 {
     if (!Form::keyEventInternal(evt, key))
-        Game::getInstance()->keyEvent(evt, key);
+    {
+        Game::getInstance()->keyEvent(evt, key);
+        ScriptController::getInstance()->keyEvent(evt, key);
+    }
 }
 
 bool Platform::mouseEventInternal(Mouse::MouseEvent evt, int x, int y, int wheelDelta)
@@ -966,10 +972,14 @@ bool Platform::mouseEventInternal(Mouse::MouseEvent evt, int x, int y, int wheel
     if (Form::mouseEventInternal(evt, x, y, wheelDelta))
     {
         return true;
-    }
-    else
-    {
-        return Game::getInstance()->mouseEvent(evt, x, y, wheelDelta);
+    }
+    else if (Game::getInstance()->mouseEvent(evt, x, y, wheelDelta))
+    {
+        return true;
+    }
+    else
+    {
+        return ScriptController::getInstance()->mouseEvent(evt, x, y, wheelDelta);
     }
 }    
 

gameplay/src/ScriptController.cpp

@@ -503,7 +503,7 @@ void ScriptController::finalizeGame()
     }
 }
 
-void ScriptController::update(long elapsedTime)
+void ScriptController::update(float elapsedTime)
 {
     if (_callbacks[UPDATE])
     {
@@ -511,7 +511,7 @@ void ScriptController::update(long elapsedTime)
     }
 }
 
-void ScriptController::render(long elapsedTime)
+void ScriptController::render(float elapsedTime)
 {
     if (_callbacks[RENDER])
     {
@@ -519,6 +519,39 @@ void ScriptController::render(long elapsedTime)
     }
 }
 
+void ScriptController::keyEvent(Keyboard::KeyEvent evt, int key)
+{
+    if (_callbacks[KEY_EVENT])
+    {
+        executeFunction<void>(_callbacks[KEY_EVENT]->c_str(), "[Keyboard::KeyEvent][Keyboard::Key]", evt, key);
+    }
+}
+
+void ScriptController::touchEvent(Touch::TouchEvent evt, int x, int y, unsigned int contactIndex)
+{
+    if (_callbacks[TOUCH_EVENT])
+    {
+        executeFunction<void>(_callbacks[TOUCH_EVENT]->c_str(), "[Touch::TouchEvent]iiui", evt, x, y, contactIndex);
+    }
+}
+
+bool ScriptController::mouseEvent(Mouse::MouseEvent evt, int x, int y, int wheelDelta)
+{
+    if (_callbacks[MOUSE_EVENT])
+    {
+        return executeFunction<bool>(_callbacks[MOUSE_EVENT]->c_str(), "[Mouse::MouseEvent]iiii", evt, x, y, wheelDelta);
+    }
+    return false;
+}
+
+void ScriptController::gamepadEvent(Gamepad::GamepadEvent evt, Gamepad* gamepad)
+{
+    if (_callbacks[GAMEPAD_EVENT])
+    {
+        executeFunction<void>(_callbacks[GAMEPAD_EVENT]->c_str(), "[Gamepad::GamepadEvent]<Gamepad>", evt, gamepad);
+    }
+}
+
 void ScriptController::executeFunctionHelper(int resultCount, const char* func, const char* args, va_list& list)
 {
     if (func == NULL)
@@ -572,6 +605,18 @@ void ScriptController::executeFunctionHelper(int resultCount, const char* func,
             case 'p':
                 lua_pushlightuserdata(_lua, va_arg(list, void*));
                 break;
+            // Enums.
+            case '[':
+            {
+                std::string type = sig;
+                type = type.substr(0, type.find("]"));
+
+                // Skip past the closing ']' (the semi-colon here is intentional-do not remove).
+                while (*sig++ != ']');
+
+                lua_pushstring(_lua, lua_stringFromEnumGlobal(type, va_arg(list, int)));
+                break;
+            }
             // Object references/pointers (Lua userdata).
             case '<':
             {
@@ -581,6 +626,16 @@ void ScriptController::executeFunctionHelper(int resultCount, const char* func,
                 // Skip past the closing '>' (the semi-colon here is intentional-do not remove).
                 while (*sig++ != '>');
 
+                // Calculate the unique Lua type name.
+                size_t i = type.find("::");
+                while (i != type.npos)
+                {
+                    // We use "" as the replacement here-this must match the preprocessor
+                    // define SCOPE_REPLACEMENT from the gameplay-luagen project.
+                    type.replace(i, 2, "");
+                    i = type.find("::");
+                }
+
                 void* ptr = va_arg(list, void*);
                 if (ptr == NULL)
                 {

gameplay/src/ScriptController.h

@@ -2,6 +2,7 @@
 #define SCRIPTCONTROLLER_H
 
 #include "Base.h"
+#include "Gamepad.h"
 
 namespace gameplay
 {
@@ -12,6 +13,7 @@ namespace gameplay
 class ScriptController
 {
     friend class Game;
+    friend class Platform;
 
 public:
 
@@ -45,7 +47,8 @@ public:
      *      - 'uh' - unsigned short
      *      - 's' - string
      *      - 'p' - pointer
-     *      - '<object-type>' - a pointer to an object of the given type (where the type is enclosed by angle brackets).
+     *      - '<object-type>' - a pointer to an object of the given type (where the qualified type name is enclosed by angle brackets).
+     *      - '[enum-type]' - an enumerated value of the given type (where the qualified type name is enclosed by square brackets).
      * @return The return value of the executed Lua function.
      * @script{ignore}
      */
@@ -95,7 +98,8 @@ public:
      *      - 'uh' - unsigned short
      *      - 's' - string
      *      - 'p' - pointer
-     *      - '<object-type>' - a pointer to an object of the given type (where the type is enclosed by angle brackets).
+     *      - '<object-type>' - a pointer to an object of the given type (where the qualified type name is enclosed by angle brackets).
+     *      - '[enum-type]' - an enumerated value of the given type (where the qualified type name is enclosed by square brackets).
      * @return The return value of the executed Lua function.
      * @script{ignore}
      */
@@ -545,7 +549,12 @@ private:
         UPDATE,
         RENDER,
         FINALIZE,
-        CALLBACK_COUNT
+        KEY_EVENT,
+        MOUSE_EVENT,
+        TOUCH_EVENT,
+        GAMEPAD_EVENT,
+        CALLBACK_COUNT,
+        INVALID_CALLBACK = CALLBACK_COUNT
     };
 
     /**
@@ -586,12 +595,59 @@ private:
     /**
      * Callback for when the controller receives a frame update event.
      */
-    void update(long elapsedTime);
+    void update(float elapsedTime);
 
     /**
      * Renders the game using the appropriate callback script (if it was specified).
      */
-    void render(long elapsedTime);
+    void render(float elapsedTime);
+
+    /**
+     * Script keyboard callback on key events.
+     *
+     * @param evt The key event that occured.
+     * @param key If evt is KEY_PRESS or KEY_RELEASE then key is the key code from Keyboard::Key.
+     *            If evt is KEY_CHAR then key is the unicode value of the character.
+     * 
+     * @see Keyboard::KeyEvent
+     * @see Keyboard::Key
+     */
+    void keyEvent(Keyboard::KeyEvent evt, int key);
+
+    /**
+     * Script touch callback on touch events.
+     *
+     * @param evt The touch event that occurred.
+     * @param x The x position of the touch in pixels. Left edge is zero.
+     * @param y The y position of the touch in pixels. Top edge is zero.
+     * @param contactIndex The order of occurrence for multiple touch contacts starting at zero.
+     *
+     * @see Touch::TouchEvent
+     */
+    void touchEvent(Touch::TouchEvent evt, int x, int y, unsigned int contactIndex);
+
+    /**
+     * Script mouse callback on mouse events. If the game does not consume the mouse move event or left mouse click event
+     * then it is interpreted as a touch event instead.
+     *
+     * @param evt The mouse event that occurred.
+     * @param x The x position of the mouse in pixels. Left edge is zero.
+     * @param y The y position of the mouse in pixels. Top edge is zero.
+     * @param wheelDelta The number of mouse wheel ticks. Positive is up (forward), negative is down (backward).
+     *
+     * @return True if the mouse event is consumed or false if it is not consumed.
+     *
+     * @see Mouse::MouseEvent
+     */
+    bool mouseEvent(Mouse::MouseEvent evt, int x, int y, int wheelDelta);
+
+    /**
+     * Script gamepad callback on gamepad events.
+     *
+     * @param evt The gamepad event that occurred.
+     * @param gamepad the gamepad the event occurred on
+     */
+    void gamepadEvent(Gamepad::GamepadEvent evt, Gamepad* gamepad);
 
     /**
      * Calls the specifed Lua function using the given parameters.
@@ -613,7 +669,8 @@ private:
      *      - 'uh' - unsigned short
      *      - 's' - string
      *      - 'p' - pointer
-     *      - '<object-type>' - a pointer to an object of the given type (where the type is enclosed by angle brackets).
+     *      - '<object-type>' - a pointer to an object of the given type (where the qualified type name is enclosed by angle brackets).
+     *      - '[enum-type]' - an enumerated value of the given type (where the qualified type name is enclosed by square brackets).
      * @param list The variable argument list.
      */
     void executeFunctionHelper(int resultCount, const char* func, const char* args, va_list& list);

gameplay/src/lua/lua_AbsoluteLayout.cpp

@@ -159,7 +159,7 @@ int lua_AbsoluteLayout_getType(lua_State* state)
                 Layout::Type result = instance->getType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_LayoutType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_LayoutType(result));
 
                 return 1;
             }

gameplay/src/lua/lua_AudioSource.cpp

@@ -297,7 +297,7 @@ int lua_AudioSource_getState(lua_State* state)
                 AudioSource::State result = instance->getState();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_AudioSourceState(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_AudioSourceState(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Button.cpp

@@ -703,7 +703,7 @@ int lua_Button_getAlignment(lua_State* state)
                 Control::Alignment result = instance->getAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result));
 
                 return 1;
             }
@@ -2134,7 +2134,7 @@ int lua_Button_getState(lua_State* state)
                 Control::State result = instance->getState();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlState(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlState(result));
 
                 return 1;
             }
@@ -2254,7 +2254,7 @@ int lua_Button_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }
@@ -2277,7 +2277,7 @@ int lua_Button_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment(param1);
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Camera.cpp

@@ -186,7 +186,7 @@ int lua_Camera_getCameraType(lua_State* state)
                 Camera::Type result = instance->getCameraType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_CameraType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_CameraType(result));
 
                 return 1;
             }

gameplay/src/lua/lua_CheckBox.cpp

@@ -708,7 +708,7 @@ int lua_CheckBox_getAlignment(lua_State* state)
                 Control::Alignment result = instance->getAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result));
 
                 return 1;
             }
@@ -2185,7 +2185,7 @@ int lua_CheckBox_getState(lua_State* state)
                 Control::State result = instance->getState();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlState(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlState(result));
 
                 return 1;
             }
@@ -2305,7 +2305,7 @@ int lua_CheckBox_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }
@@ -2328,7 +2328,7 @@ int lua_CheckBox_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment(param1);
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Container.cpp

@@ -753,7 +753,7 @@ int lua_Container_getAlignment(lua_State* state)
                 Control::Alignment result = instance->getAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result));
 
                 return 1;
             }
@@ -2147,7 +2147,7 @@ int lua_Container_getScroll(lua_State* state)
                 Container::Scroll result = instance->getScroll();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ContainerScroll(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ContainerScroll(result));
 
                 return 1;
             }
@@ -2340,7 +2340,7 @@ int lua_Container_getState(lua_State* state)
                 Control::State result = instance->getState();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlState(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlState(result));
 
                 return 1;
             }
@@ -2423,7 +2423,7 @@ int lua_Container_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }
@@ -2446,7 +2446,7 @@ int lua_Container_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment(param1);
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Control.cpp

@@ -701,7 +701,7 @@ int lua_Control_getAlignment(lua_State* state)
                 Control::Alignment result = instance->getAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result));
 
                 return 1;
             }
@@ -2132,7 +2132,7 @@ int lua_Control_getState(lua_State* state)
                 Control::State result = instance->getState();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlState(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlState(result));
 
                 return 1;
             }
@@ -2215,7 +2215,7 @@ int lua_Control_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }
@@ -2238,7 +2238,7 @@ int lua_Control_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment(param1);
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }

gameplay/src/lua/lua_DepthStencilTarget.cpp

@@ -128,7 +128,7 @@ int lua_DepthStencilTarget_getFormat(lua_State* state)
                 DepthStencilTarget::Format result = instance->getFormat();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_DepthStencilTargetFormat(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_DepthStencilTargetFormat(result));
 
                 return 1;
             }

gameplay/src/lua/lua_FlowLayout.cpp

@@ -159,7 +159,7 @@ int lua_FlowLayout_getType(lua_State* state)
                 Layout::Type result = instance->getType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_LayoutType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_LayoutType(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Font.cpp

@@ -1733,7 +1733,7 @@ int lua_Font_static_getJustify(lua_State* state)
                 Font::Justify result = Font::getJustify(param1);
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Form.cpp

@@ -792,7 +792,7 @@ int lua_Form_getAlignment(lua_State* state)
                 Control::Alignment result = instance->getAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result));
 
                 return 1;
             }
@@ -2186,7 +2186,7 @@ int lua_Form_getScroll(lua_State* state)
                 Container::Scroll result = instance->getScroll();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ContainerScroll(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ContainerScroll(result));
 
                 return 1;
             }
@@ -2379,7 +2379,7 @@ int lua_Form_getState(lua_State* state)
                 Control::State result = instance->getState();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlState(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlState(result));
 
                 return 1;
             }
@@ -2462,7 +2462,7 @@ int lua_Form_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }
@@ -2485,7 +2485,7 @@ int lua_Form_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment(param1);
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Game.cpp

@@ -779,7 +779,7 @@ int lua_Game_getState(lua_State* state)
                 Game::State result = instance->getState();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_GameState(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_GameState(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Gamepad.cpp

@@ -129,7 +129,7 @@ int lua_Gamepad_getButtonState(lua_State* state)
                 Gamepad::ButtonState result = instance->getButtonState(param1);
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_GamepadButtonState(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_GamepadButtonState(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Global.cpp

@@ -836,2008 +836,2518 @@ int lua__printError(lua_State* state)
     return 0;
 }
 
+static const char* enumStringEmpty = "";
+
+static const char* luaEnumString_AnimationClipListenerEventType_DEFAULT = "DEFAULT";
+static const char* luaEnumString_AnimationClipListenerEventType_BEGIN = "BEGIN";
+static const char* luaEnumString_AnimationClipListenerEventType_END = "END";
+
 AnimationClip::Listener::EventType lua_enumFromString_AnimationClipListenerEventType(const char* s)
 {
-    if (strcmp(s, "DEFAULT") == 0)
+    if (strcmp(s, luaEnumString_AnimationClipListenerEventType_DEFAULT) == 0)
         return AnimationClip::Listener::DEFAULT;
-    if (strcmp(s, "BEGIN") == 0)
+    if (strcmp(s, luaEnumString_AnimationClipListenerEventType_BEGIN) == 0)
         return AnimationClip::Listener::BEGIN;
-    if (strcmp(s, "END") == 0)
+    if (strcmp(s, luaEnumString_AnimationClipListenerEventType_END) == 0)
         return AnimationClip::Listener::END;
     GP_ERROR("Invalid enumeration value '%s' for enumeration AnimationClip::Listener::EventType.", s);
     return AnimationClip::Listener::DEFAULT;
 }
 
-std::string lua_stringFromEnum_AnimationClipListenerEventType(AnimationClip::Listener::EventType e)
+const char* lua_stringFromEnum_AnimationClipListenerEventType(AnimationClip::Listener::EventType e)
 {
     if (e == AnimationClip::Listener::DEFAULT)
-        return std::string("DEFAULT");
+        return luaEnumString_AnimationClipListenerEventType_DEFAULT;
     if (e == AnimationClip::Listener::BEGIN)
-        return std::string("BEGIN");
+        return luaEnumString_AnimationClipListenerEventType_BEGIN;
     if (e == AnimationClip::Listener::END)
-        return std::string("END");
+        return luaEnumString_AnimationClipListenerEventType_END;
     GP_ERROR("Invalid enumeration value '%d' for enumeration AnimationClip::Listener::EventType.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_AudioSourceState_INITIAL = "INITIAL";
+static const char* luaEnumString_AudioSourceState_PLAYING = "PLAYING";
+static const char* luaEnumString_AudioSourceState_PAUSED = "PAUSED";
+static const char* luaEnumString_AudioSourceState_STOPPED = "STOPPED";
+
 AudioSource::State lua_enumFromString_AudioSourceState(const char* s)
 {
-    if (strcmp(s, "INITIAL") == 0)
+    if (strcmp(s, luaEnumString_AudioSourceState_INITIAL) == 0)
         return AudioSource::INITIAL;
-    if (strcmp(s, "PLAYING") == 0)
+    if (strcmp(s, luaEnumString_AudioSourceState_PLAYING) == 0)
         return AudioSource::PLAYING;
-    if (strcmp(s, "PAUSED") == 0)
+    if (strcmp(s, luaEnumString_AudioSourceState_PAUSED) == 0)
         return AudioSource::PAUSED;
-    if (strcmp(s, "STOPPED") == 0)
+    if (strcmp(s, luaEnumString_AudioSourceState_STOPPED) == 0)
         return AudioSource::STOPPED;
     GP_ERROR("Invalid enumeration value '%s' for enumeration AudioSource::State.", s);
     return AudioSource::INITIAL;
 }
 
-std::string lua_stringFromEnum_AudioSourceState(AudioSource::State e)
+const char* lua_stringFromEnum_AudioSourceState(AudioSource::State e)
 {
     if (e == AudioSource::INITIAL)
-        return std::string("INITIAL");
+        return luaEnumString_AudioSourceState_INITIAL;
     if (e == AudioSource::PLAYING)
-        return std::string("PLAYING");
+        return luaEnumString_AudioSourceState_PLAYING;
     if (e == AudioSource::PAUSED)
-        return std::string("PAUSED");
+        return luaEnumString_AudioSourceState_PAUSED;
     if (e == AudioSource::STOPPED)
-        return std::string("STOPPED");
+        return luaEnumString_AudioSourceState_STOPPED;
     GP_ERROR("Invalid enumeration value '%d' for enumeration AudioSource::State.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_CameraType_PERSPECTIVE = "PERSPECTIVE";
+static const char* luaEnumString_CameraType_ORTHOGRAPHIC = "ORTHOGRAPHIC";
+
 Camera::Type lua_enumFromString_CameraType(const char* s)
 {
-    if (strcmp(s, "PERSPECTIVE") == 0)
+    if (strcmp(s, luaEnumString_CameraType_PERSPECTIVE) == 0)
         return Camera::PERSPECTIVE;
-    if (strcmp(s, "ORTHOGRAPHIC") == 0)
+    if (strcmp(s, luaEnumString_CameraType_ORTHOGRAPHIC) == 0)
         return Camera::ORTHOGRAPHIC;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Camera::Type.", s);
     return Camera::PERSPECTIVE;
 }
 
-std::string lua_stringFromEnum_CameraType(Camera::Type e)
+const char* lua_stringFromEnum_CameraType(Camera::Type e)
 {
     if (e == Camera::PERSPECTIVE)
-        return std::string("PERSPECTIVE");
+        return luaEnumString_CameraType_PERSPECTIVE;
     if (e == Camera::ORTHOGRAPHIC)
-        return std::string("ORTHOGRAPHIC");
+        return luaEnumString_CameraType_ORTHOGRAPHIC;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Camera::Type.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_ContainerScroll_SCROLL_NONE = "SCROLL_NONE";
+static const char* luaEnumString_ContainerScroll_SCROLL_HORIZONTAL = "SCROLL_HORIZONTAL";
+static const char* luaEnumString_ContainerScroll_SCROLL_VERTICAL = "SCROLL_VERTICAL";
+static const char* luaEnumString_ContainerScroll_SCROLL_BOTH = "SCROLL_BOTH";
+
 Container::Scroll lua_enumFromString_ContainerScroll(const char* s)
 {
-    if (strcmp(s, "SCROLL_NONE") == 0)
+    if (strcmp(s, luaEnumString_ContainerScroll_SCROLL_NONE) == 0)
         return Container::SCROLL_NONE;
-    if (strcmp(s, "SCROLL_HORIZONTAL") == 0)
+    if (strcmp(s, luaEnumString_ContainerScroll_SCROLL_HORIZONTAL) == 0)
         return Container::SCROLL_HORIZONTAL;
-    if (strcmp(s, "SCROLL_VERTICAL") == 0)
+    if (strcmp(s, luaEnumString_ContainerScroll_SCROLL_VERTICAL) == 0)
         return Container::SCROLL_VERTICAL;
-    if (strcmp(s, "SCROLL_BOTH") == 0)
+    if (strcmp(s, luaEnumString_ContainerScroll_SCROLL_BOTH) == 0)
         return Container::SCROLL_BOTH;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Container::Scroll.", s);
     return Container::SCROLL_NONE;
 }
 
-std::string lua_stringFromEnum_ContainerScroll(Container::Scroll e)
+const char* lua_stringFromEnum_ContainerScroll(Container::Scroll e)
 {
     if (e == Container::SCROLL_NONE)
-        return std::string("SCROLL_NONE");
+        return luaEnumString_ContainerScroll_SCROLL_NONE;
     if (e == Container::SCROLL_HORIZONTAL)
-        return std::string("SCROLL_HORIZONTAL");
+        return luaEnumString_ContainerScroll_SCROLL_HORIZONTAL;
     if (e == Container::SCROLL_VERTICAL)
-        return std::string("SCROLL_VERTICAL");
+        return luaEnumString_ContainerScroll_SCROLL_VERTICAL;
     if (e == Container::SCROLL_BOTH)
-        return std::string("SCROLL_BOTH");
+        return luaEnumString_ContainerScroll_SCROLL_BOTH;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Container::Scroll.", e);
-    return std::string();
-}
+    return enumStringEmpty;
+}
+
+static const char* luaEnumString_ControlAlignment_ALIGN_LEFT = "ALIGN_LEFT";
+static const char* luaEnumString_ControlAlignment_ALIGN_HCENTER = "ALIGN_HCENTER";
+static const char* luaEnumString_ControlAlignment_ALIGN_RIGHT = "ALIGN_RIGHT";
+static const char* luaEnumString_ControlAlignment_ALIGN_TOP = "ALIGN_TOP";
+static const char* luaEnumString_ControlAlignment_ALIGN_VCENTER = "ALIGN_VCENTER";
+static const char* luaEnumString_ControlAlignment_ALIGN_BOTTOM = "ALIGN_BOTTOM";
+static const char* luaEnumString_ControlAlignment_ALIGN_TOP_LEFT = "ALIGN_TOP_LEFT";
+static const char* luaEnumString_ControlAlignment_ALIGN_VCENTER_LEFT = "ALIGN_VCENTER_LEFT";
+static const char* luaEnumString_ControlAlignment_ALIGN_BOTTOM_LEFT = "ALIGN_BOTTOM_LEFT";
+static const char* luaEnumString_ControlAlignment_ALIGN_TOP_HCENTER = "ALIGN_TOP_HCENTER";
+static const char* luaEnumString_ControlAlignment_ALIGN_VCENTER_HCENTER = "ALIGN_VCENTER_HCENTER";
+static const char* luaEnumString_ControlAlignment_ALIGN_BOTTOM_HCENTER = "ALIGN_BOTTOM_HCENTER";
+static const char* luaEnumString_ControlAlignment_ALIGN_TOP_RIGHT = "ALIGN_TOP_RIGHT";
+static const char* luaEnumString_ControlAlignment_ALIGN_VCENTER_RIGHT = "ALIGN_VCENTER_RIGHT";
+static const char* luaEnumString_ControlAlignment_ALIGN_BOTTOM_RIGHT = "ALIGN_BOTTOM_RIGHT";
 
 Control::Alignment lua_enumFromString_ControlAlignment(const char* s)
 {
-    if (strcmp(s, "ALIGN_LEFT") == 0)
+    if (strcmp(s, luaEnumString_ControlAlignment_ALIGN_LEFT) == 0)
         return Control::ALIGN_LEFT;
-    if (strcmp(s, "ALIGN_HCENTER") == 0)
+    if (strcmp(s, luaEnumString_ControlAlignment_ALIGN_HCENTER) == 0)
         return Control::ALIGN_HCENTER;
-    if (strcmp(s, "ALIGN_RIGHT") == 0)
+    if (strcmp(s, luaEnumString_ControlAlignment_ALIGN_RIGHT) == 0)
         return Control::ALIGN_RIGHT;
-    if (strcmp(s, "ALIGN_TOP") == 0)
+    if (strcmp(s, luaEnumString_ControlAlignment_ALIGN_TOP) == 0)
         return Control::ALIGN_TOP;
-    if (strcmp(s, "ALIGN_VCENTER") == 0)
+    if (strcmp(s, luaEnumString_ControlAlignment_ALIGN_VCENTER) == 0)
         return Control::ALIGN_VCENTER;
-    if (strcmp(s, "ALIGN_BOTTOM") == 0)
+    if (strcmp(s, luaEnumString_ControlAlignment_ALIGN_BOTTOM) == 0)
         return Control::ALIGN_BOTTOM;
-    if (strcmp(s, "ALIGN_TOP_LEFT") == 0)
+    if (strcmp(s, luaEnumString_ControlAlignment_ALIGN_TOP_LEFT) == 0)
         return Control::ALIGN_TOP_LEFT;
-    if (strcmp(s, "ALIGN_VCENTER_LEFT") == 0)
+    if (strcmp(s, luaEnumString_ControlAlignment_ALIGN_VCENTER_LEFT) == 0)
         return Control::ALIGN_VCENTER_LEFT;
-    if (strcmp(s, "ALIGN_BOTTOM_LEFT") == 0)
+    if (strcmp(s, luaEnumString_ControlAlignment_ALIGN_BOTTOM_LEFT) == 0)
         return Control::ALIGN_BOTTOM_LEFT;
-    if (strcmp(s, "ALIGN_TOP_HCENTER") == 0)
+    if (strcmp(s, luaEnumString_ControlAlignment_ALIGN_TOP_HCENTER) == 0)
         return Control::ALIGN_TOP_HCENTER;
-    if (strcmp(s, "ALIGN_VCENTER_HCENTER") == 0)
+    if (strcmp(s, luaEnumString_ControlAlignment_ALIGN_VCENTER_HCENTER) == 0)
         return Control::ALIGN_VCENTER_HCENTER;
-    if (strcmp(s, "ALIGN_BOTTOM_HCENTER") == 0)
+    if (strcmp(s, luaEnumString_ControlAlignment_ALIGN_BOTTOM_HCENTER) == 0)
         return Control::ALIGN_BOTTOM_HCENTER;
-    if (strcmp(s, "ALIGN_TOP_RIGHT") == 0)
+    if (strcmp(s, luaEnumString_ControlAlignment_ALIGN_TOP_RIGHT) == 0)
         return Control::ALIGN_TOP_RIGHT;
-    if (strcmp(s, "ALIGN_VCENTER_RIGHT") == 0)
+    if (strcmp(s, luaEnumString_ControlAlignment_ALIGN_VCENTER_RIGHT) == 0)
         return Control::ALIGN_VCENTER_RIGHT;
-    if (strcmp(s, "ALIGN_BOTTOM_RIGHT") == 0)
+    if (strcmp(s, luaEnumString_ControlAlignment_ALIGN_BOTTOM_RIGHT) == 0)
         return Control::ALIGN_BOTTOM_RIGHT;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Control::Alignment.", s);
     return Control::ALIGN_LEFT;
 }
 
-std::string lua_stringFromEnum_ControlAlignment(Control::Alignment e)
+const char* lua_stringFromEnum_ControlAlignment(Control::Alignment e)
 {
     if (e == Control::ALIGN_LEFT)
-        return std::string("ALIGN_LEFT");
+        return luaEnumString_ControlAlignment_ALIGN_LEFT;
     if (e == Control::ALIGN_HCENTER)
-        return std::string("ALIGN_HCENTER");
+        return luaEnumString_ControlAlignment_ALIGN_HCENTER;
     if (e == Control::ALIGN_RIGHT)
-        return std::string("ALIGN_RIGHT");
+        return luaEnumString_ControlAlignment_ALIGN_RIGHT;
     if (e == Control::ALIGN_TOP)
-        return std::string("ALIGN_TOP");
+        return luaEnumString_ControlAlignment_ALIGN_TOP;
     if (e == Control::ALIGN_VCENTER)
-        return std::string("ALIGN_VCENTER");
+        return luaEnumString_ControlAlignment_ALIGN_VCENTER;
     if (e == Control::ALIGN_BOTTOM)
-        return std::string("ALIGN_BOTTOM");
+        return luaEnumString_ControlAlignment_ALIGN_BOTTOM;
     if (e == Control::ALIGN_TOP_LEFT)
-        return std::string("ALIGN_TOP_LEFT");
+        return luaEnumString_ControlAlignment_ALIGN_TOP_LEFT;
     if (e == Control::ALIGN_VCENTER_LEFT)
-        return std::string("ALIGN_VCENTER_LEFT");
+        return luaEnumString_ControlAlignment_ALIGN_VCENTER_LEFT;
     if (e == Control::ALIGN_BOTTOM_LEFT)
-        return std::string("ALIGN_BOTTOM_LEFT");
+        return luaEnumString_ControlAlignment_ALIGN_BOTTOM_LEFT;
     if (e == Control::ALIGN_TOP_HCENTER)
-        return std::string("ALIGN_TOP_HCENTER");
+        return luaEnumString_ControlAlignment_ALIGN_TOP_HCENTER;
     if (e == Control::ALIGN_VCENTER_HCENTER)
-        return std::string("ALIGN_VCENTER_HCENTER");
+        return luaEnumString_ControlAlignment_ALIGN_VCENTER_HCENTER;
     if (e == Control::ALIGN_BOTTOM_HCENTER)
-        return std::string("ALIGN_BOTTOM_HCENTER");
+        return luaEnumString_ControlAlignment_ALIGN_BOTTOM_HCENTER;
     if (e == Control::ALIGN_TOP_RIGHT)
-        return std::string("ALIGN_TOP_RIGHT");
+        return luaEnumString_ControlAlignment_ALIGN_TOP_RIGHT;
     if (e == Control::ALIGN_VCENTER_RIGHT)
-        return std::string("ALIGN_VCENTER_RIGHT");
+        return luaEnumString_ControlAlignment_ALIGN_VCENTER_RIGHT;
     if (e == Control::ALIGN_BOTTOM_RIGHT)
-        return std::string("ALIGN_BOTTOM_RIGHT");
+        return luaEnumString_ControlAlignment_ALIGN_BOTTOM_RIGHT;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Control::Alignment.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_ControlListenerEventType_PRESS = "PRESS";
+static const char* luaEnumString_ControlListenerEventType_RELEASE = "RELEASE";
+static const char* luaEnumString_ControlListenerEventType_CLICK = "CLICK";
+static const char* luaEnumString_ControlListenerEventType_VALUE_CHANGED = "VALUE_CHANGED";
+static const char* luaEnumString_ControlListenerEventType_TEXT_CHANGED = "TEXT_CHANGED";
+static const char* luaEnumString_ControlListenerEventType_MIDDLE_CLICK = "MIDDLE_CLICK";
+static const char* luaEnumString_ControlListenerEventType_RIGHT_CLICK = "RIGHT_CLICK";
+
 Control::Listener::EventType lua_enumFromString_ControlListenerEventType(const char* s)
 {
-    if (strcmp(s, "PRESS") == 0)
+    if (strcmp(s, luaEnumString_ControlListenerEventType_PRESS) == 0)
         return Control::Listener::PRESS;
-    if (strcmp(s, "RELEASE") == 0)
+    if (strcmp(s, luaEnumString_ControlListenerEventType_RELEASE) == 0)
         return Control::Listener::RELEASE;
-    if (strcmp(s, "CLICK") == 0)
+    if (strcmp(s, luaEnumString_ControlListenerEventType_CLICK) == 0)
         return Control::Listener::CLICK;
-    if (strcmp(s, "VALUE_CHANGED") == 0)
+    if (strcmp(s, luaEnumString_ControlListenerEventType_VALUE_CHANGED) == 0)
         return Control::Listener::VALUE_CHANGED;
-    if (strcmp(s, "TEXT_CHANGED") == 0)
+    if (strcmp(s, luaEnumString_ControlListenerEventType_TEXT_CHANGED) == 0)
         return Control::Listener::TEXT_CHANGED;
-    if (strcmp(s, "MIDDLE_CLICK") == 0)
+    if (strcmp(s, luaEnumString_ControlListenerEventType_MIDDLE_CLICK) == 0)
         return Control::Listener::MIDDLE_CLICK;
-    if (strcmp(s, "RIGHT_CLICK") == 0)
+    if (strcmp(s, luaEnumString_ControlListenerEventType_RIGHT_CLICK) == 0)
         return Control::Listener::RIGHT_CLICK;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Control::Listener::EventType.", s);
     return Control::Listener::PRESS;
 }
 
-std::string lua_stringFromEnum_ControlListenerEventType(Control::Listener::EventType e)
+const char* lua_stringFromEnum_ControlListenerEventType(Control::Listener::EventType e)
 {
     if (e == Control::Listener::PRESS)
-        return std::string("PRESS");
+        return luaEnumString_ControlListenerEventType_PRESS;
     if (e == Control::Listener::RELEASE)
-        return std::string("RELEASE");
+        return luaEnumString_ControlListenerEventType_RELEASE;
     if (e == Control::Listener::CLICK)
-        return std::string("CLICK");
+        return luaEnumString_ControlListenerEventType_CLICK;
     if (e == Control::Listener::VALUE_CHANGED)
-        return std::string("VALUE_CHANGED");
+        return luaEnumString_ControlListenerEventType_VALUE_CHANGED;
     if (e == Control::Listener::TEXT_CHANGED)
-        return std::string("TEXT_CHANGED");
+        return luaEnumString_ControlListenerEventType_TEXT_CHANGED;
     if (e == Control::Listener::MIDDLE_CLICK)
-        return std::string("MIDDLE_CLICK");
+        return luaEnumString_ControlListenerEventType_MIDDLE_CLICK;
     if (e == Control::Listener::RIGHT_CLICK)
-        return std::string("RIGHT_CLICK");
+        return luaEnumString_ControlListenerEventType_RIGHT_CLICK;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Control::Listener::EventType.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_ControlState_NORMAL = "NORMAL";
+static const char* luaEnumString_ControlState_FOCUS = "FOCUS";
+static const char* luaEnumString_ControlState_ACTIVE = "ACTIVE";
+static const char* luaEnumString_ControlState_DISABLED = "DISABLED";
+
 Control::State lua_enumFromString_ControlState(const char* s)
 {
-    if (strcmp(s, "NORMAL") == 0)
+    if (strcmp(s, luaEnumString_ControlState_NORMAL) == 0)
         return Control::NORMAL;
-    if (strcmp(s, "FOCUS") == 0)
+    if (strcmp(s, luaEnumString_ControlState_FOCUS) == 0)
         return Control::FOCUS;
-    if (strcmp(s, "ACTIVE") == 0)
+    if (strcmp(s, luaEnumString_ControlState_ACTIVE) == 0)
         return Control::ACTIVE;
-    if (strcmp(s, "DISABLED") == 0)
+    if (strcmp(s, luaEnumString_ControlState_DISABLED) == 0)
         return Control::DISABLED;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Control::State.", s);
     return Control::NORMAL;
 }
 
-std::string lua_stringFromEnum_ControlState(Control::State e)
+const char* lua_stringFromEnum_ControlState(Control::State e)
 {
     if (e == Control::NORMAL)
-        return std::string("NORMAL");
+        return luaEnumString_ControlState_NORMAL;
     if (e == Control::FOCUS)
-        return std::string("FOCUS");
+        return luaEnumString_ControlState_FOCUS;
     if (e == Control::ACTIVE)
-        return std::string("ACTIVE");
+        return luaEnumString_ControlState_ACTIVE;
     if (e == Control::DISABLED)
-        return std::string("DISABLED");
+        return luaEnumString_ControlState_DISABLED;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Control::State.", e);
-    return std::string();
-}
+    return enumStringEmpty;
+}
+
+static const char* luaEnumString_CurveInterpolationType_BEZIER = "BEZIER";
+static const char* luaEnumString_CurveInterpolationType_BSPLINE = "BSPLINE";
+static const char* luaEnumString_CurveInterpolationType_FLAT = "FLAT";
+static const char* luaEnumString_CurveInterpolationType_HERMITE = "HERMITE";
+static const char* luaEnumString_CurveInterpolationType_LINEAR = "LINEAR";
+static const char* luaEnumString_CurveInterpolationType_SMOOTH = "SMOOTH";
+static const char* luaEnumString_CurveInterpolationType_STEP = "STEP";
+static const char* luaEnumString_CurveInterpolationType_QUADRATIC_IN = "QUADRATIC_IN";
+static const char* luaEnumString_CurveInterpolationType_QUADRATIC_OUT = "QUADRATIC_OUT";
+static const char* luaEnumString_CurveInterpolationType_QUADRATIC_IN_OUT = "QUADRATIC_IN_OUT";
+static const char* luaEnumString_CurveInterpolationType_QUADRATIC_OUT_IN = "QUADRATIC_OUT_IN";
+static const char* luaEnumString_CurveInterpolationType_CUBIC_IN = "CUBIC_IN";
+static const char* luaEnumString_CurveInterpolationType_CUBIC_OUT = "CUBIC_OUT";
+static const char* luaEnumString_CurveInterpolationType_CUBIC_IN_OUT = "CUBIC_IN_OUT";
+static const char* luaEnumString_CurveInterpolationType_CUBIC_OUT_IN = "CUBIC_OUT_IN";
+static const char* luaEnumString_CurveInterpolationType_QUARTIC_IN = "QUARTIC_IN";
+static const char* luaEnumString_CurveInterpolationType_QUARTIC_OUT = "QUARTIC_OUT";
+static const char* luaEnumString_CurveInterpolationType_QUARTIC_IN_OUT = "QUARTIC_IN_OUT";
+static const char* luaEnumString_CurveInterpolationType_QUARTIC_OUT_IN = "QUARTIC_OUT_IN";
+static const char* luaEnumString_CurveInterpolationType_QUINTIC_IN = "QUINTIC_IN";
+static const char* luaEnumString_CurveInterpolationType_QUINTIC_OUT = "QUINTIC_OUT";
+static const char* luaEnumString_CurveInterpolationType_QUINTIC_IN_OUT = "QUINTIC_IN_OUT";
+static const char* luaEnumString_CurveInterpolationType_QUINTIC_OUT_IN = "QUINTIC_OUT_IN";
+static const char* luaEnumString_CurveInterpolationType_SINE_IN = "SINE_IN";
+static const char* luaEnumString_CurveInterpolationType_SINE_OUT = "SINE_OUT";
+static const char* luaEnumString_CurveInterpolationType_SINE_IN_OUT = "SINE_IN_OUT";
+static const char* luaEnumString_CurveInterpolationType_SINE_OUT_IN = "SINE_OUT_IN";
+static const char* luaEnumString_CurveInterpolationType_EXPONENTIAL_IN = "EXPONENTIAL_IN";
+static const char* luaEnumString_CurveInterpolationType_EXPONENTIAL_OUT = "EXPONENTIAL_OUT";
+static const char* luaEnumString_CurveInterpolationType_EXPONENTIAL_IN_OUT = "EXPONENTIAL_IN_OUT";
+static const char* luaEnumString_CurveInterpolationType_EXPONENTIAL_OUT_IN = "EXPONENTIAL_OUT_IN";
+static const char* luaEnumString_CurveInterpolationType_CIRCULAR_IN = "CIRCULAR_IN";
+static const char* luaEnumString_CurveInterpolationType_CIRCULAR_OUT = "CIRCULAR_OUT";
+static const char* luaEnumString_CurveInterpolationType_CIRCULAR_IN_OUT = "CIRCULAR_IN_OUT";
+static const char* luaEnumString_CurveInterpolationType_CIRCULAR_OUT_IN = "CIRCULAR_OUT_IN";
+static const char* luaEnumString_CurveInterpolationType_ELASTIC_IN = "ELASTIC_IN";
+static const char* luaEnumString_CurveInterpolationType_ELASTIC_OUT = "ELASTIC_OUT";
+static const char* luaEnumString_CurveInterpolationType_ELASTIC_IN_OUT = "ELASTIC_IN_OUT";
+static const char* luaEnumString_CurveInterpolationType_ELASTIC_OUT_IN = "ELASTIC_OUT_IN";
+static const char* luaEnumString_CurveInterpolationType_OVERSHOOT_IN = "OVERSHOOT_IN";
+static const char* luaEnumString_CurveInterpolationType_OVERSHOOT_OUT = "OVERSHOOT_OUT";
+static const char* luaEnumString_CurveInterpolationType_OVERSHOOT_IN_OUT = "OVERSHOOT_IN_OUT";
+static const char* luaEnumString_CurveInterpolationType_OVERSHOOT_OUT_IN = "OVERSHOOT_OUT_IN";
+static const char* luaEnumString_CurveInterpolationType_BOUNCE_IN = "BOUNCE_IN";
+static const char* luaEnumString_CurveInterpolationType_BOUNCE_OUT = "BOUNCE_OUT";
+static const char* luaEnumString_CurveInterpolationType_BOUNCE_IN_OUT = "BOUNCE_IN_OUT";
+static const char* luaEnumString_CurveInterpolationType_BOUNCE_OUT_IN = "BOUNCE_OUT_IN";
 
 Curve::InterpolationType lua_enumFromString_CurveInterpolationType(const char* s)
 {
-    if (strcmp(s, "BEZIER") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_BEZIER) == 0)
         return Curve::BEZIER;
-    if (strcmp(s, "BSPLINE") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_BSPLINE) == 0)
         return Curve::BSPLINE;
-    if (strcmp(s, "FLAT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_FLAT) == 0)
         return Curve::FLAT;
-    if (strcmp(s, "HERMITE") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_HERMITE) == 0)
         return Curve::HERMITE;
-    if (strcmp(s, "LINEAR") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_LINEAR) == 0)
         return Curve::LINEAR;
-    if (strcmp(s, "SMOOTH") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_SMOOTH) == 0)
         return Curve::SMOOTH;
-    if (strcmp(s, "STEP") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_STEP) == 0)
         return Curve::STEP;
-    if (strcmp(s, "QUADRATIC_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_QUADRATIC_IN) == 0)
         return Curve::QUADRATIC_IN;
-    if (strcmp(s, "QUADRATIC_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_QUADRATIC_OUT) == 0)
         return Curve::QUADRATIC_OUT;
-    if (strcmp(s, "QUADRATIC_IN_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_QUADRATIC_IN_OUT) == 0)
         return Curve::QUADRATIC_IN_OUT;
-    if (strcmp(s, "QUADRATIC_OUT_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_QUADRATIC_OUT_IN) == 0)
         return Curve::QUADRATIC_OUT_IN;
-    if (strcmp(s, "CUBIC_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_CUBIC_IN) == 0)
         return Curve::CUBIC_IN;
-    if (strcmp(s, "CUBIC_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_CUBIC_OUT) == 0)
         return Curve::CUBIC_OUT;
-    if (strcmp(s, "CUBIC_IN_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_CUBIC_IN_OUT) == 0)
         return Curve::CUBIC_IN_OUT;
-    if (strcmp(s, "CUBIC_OUT_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_CUBIC_OUT_IN) == 0)
         return Curve::CUBIC_OUT_IN;
-    if (strcmp(s, "QUARTIC_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_QUARTIC_IN) == 0)
         return Curve::QUARTIC_IN;
-    if (strcmp(s, "QUARTIC_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_QUARTIC_OUT) == 0)
         return Curve::QUARTIC_OUT;
-    if (strcmp(s, "QUARTIC_IN_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_QUARTIC_IN_OUT) == 0)
         return Curve::QUARTIC_IN_OUT;
-    if (strcmp(s, "QUARTIC_OUT_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_QUARTIC_OUT_IN) == 0)
         return Curve::QUARTIC_OUT_IN;
-    if (strcmp(s, "QUINTIC_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_QUINTIC_IN) == 0)
         return Curve::QUINTIC_IN;
-    if (strcmp(s, "QUINTIC_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_QUINTIC_OUT) == 0)
         return Curve::QUINTIC_OUT;
-    if (strcmp(s, "QUINTIC_IN_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_QUINTIC_IN_OUT) == 0)
         return Curve::QUINTIC_IN_OUT;
-    if (strcmp(s, "QUINTIC_OUT_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_QUINTIC_OUT_IN) == 0)
         return Curve::QUINTIC_OUT_IN;
-    if (strcmp(s, "SINE_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_SINE_IN) == 0)
         return Curve::SINE_IN;
-    if (strcmp(s, "SINE_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_SINE_OUT) == 0)
         return Curve::SINE_OUT;
-    if (strcmp(s, "SINE_IN_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_SINE_IN_OUT) == 0)
         return Curve::SINE_IN_OUT;
-    if (strcmp(s, "SINE_OUT_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_SINE_OUT_IN) == 0)
         return Curve::SINE_OUT_IN;
-    if (strcmp(s, "EXPONENTIAL_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_EXPONENTIAL_IN) == 0)
         return Curve::EXPONENTIAL_IN;
-    if (strcmp(s, "EXPONENTIAL_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_EXPONENTIAL_OUT) == 0)
         return Curve::EXPONENTIAL_OUT;
-    if (strcmp(s, "EXPONENTIAL_IN_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_EXPONENTIAL_IN_OUT) == 0)
         return Curve::EXPONENTIAL_IN_OUT;
-    if (strcmp(s, "EXPONENTIAL_OUT_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_EXPONENTIAL_OUT_IN) == 0)
         return Curve::EXPONENTIAL_OUT_IN;
-    if (strcmp(s, "CIRCULAR_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_CIRCULAR_IN) == 0)
         return Curve::CIRCULAR_IN;
-    if (strcmp(s, "CIRCULAR_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_CIRCULAR_OUT) == 0)
         return Curve::CIRCULAR_OUT;
-    if (strcmp(s, "CIRCULAR_IN_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_CIRCULAR_IN_OUT) == 0)
         return Curve::CIRCULAR_IN_OUT;
-    if (strcmp(s, "CIRCULAR_OUT_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_CIRCULAR_OUT_IN) == 0)
         return Curve::CIRCULAR_OUT_IN;
-    if (strcmp(s, "ELASTIC_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_ELASTIC_IN) == 0)
         return Curve::ELASTIC_IN;
-    if (strcmp(s, "ELASTIC_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_ELASTIC_OUT) == 0)
         return Curve::ELASTIC_OUT;
-    if (strcmp(s, "ELASTIC_IN_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_ELASTIC_IN_OUT) == 0)
         return Curve::ELASTIC_IN_OUT;
-    if (strcmp(s, "ELASTIC_OUT_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_ELASTIC_OUT_IN) == 0)
         return Curve::ELASTIC_OUT_IN;
-    if (strcmp(s, "OVERSHOOT_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_OVERSHOOT_IN) == 0)
         return Curve::OVERSHOOT_IN;
-    if (strcmp(s, "OVERSHOOT_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_OVERSHOOT_OUT) == 0)
         return Curve::OVERSHOOT_OUT;
-    if (strcmp(s, "OVERSHOOT_IN_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_OVERSHOOT_IN_OUT) == 0)
         return Curve::OVERSHOOT_IN_OUT;
-    if (strcmp(s, "OVERSHOOT_OUT_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_OVERSHOOT_OUT_IN) == 0)
         return Curve::OVERSHOOT_OUT_IN;
-    if (strcmp(s, "BOUNCE_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_BOUNCE_IN) == 0)
         return Curve::BOUNCE_IN;
-    if (strcmp(s, "BOUNCE_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_BOUNCE_OUT) == 0)
         return Curve::BOUNCE_OUT;
-    if (strcmp(s, "BOUNCE_IN_OUT") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_BOUNCE_IN_OUT) == 0)
         return Curve::BOUNCE_IN_OUT;
-    if (strcmp(s, "BOUNCE_OUT_IN") == 0)
+    if (strcmp(s, luaEnumString_CurveInterpolationType_BOUNCE_OUT_IN) == 0)
         return Curve::BOUNCE_OUT_IN;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Curve::InterpolationType.", s);
     return Curve::BEZIER;
 }
 
-std::string lua_stringFromEnum_CurveInterpolationType(Curve::InterpolationType e)
+const char* lua_stringFromEnum_CurveInterpolationType(Curve::InterpolationType e)
 {
     if (e == Curve::BEZIER)
-        return std::string("BEZIER");
+        return luaEnumString_CurveInterpolationType_BEZIER;
     if (e == Curve::BSPLINE)
-        return std::string("BSPLINE");
+        return luaEnumString_CurveInterpolationType_BSPLINE;
     if (e == Curve::FLAT)
-        return std::string("FLAT");
+        return luaEnumString_CurveInterpolationType_FLAT;
     if (e == Curve::HERMITE)
-        return std::string("HERMITE");
+        return luaEnumString_CurveInterpolationType_HERMITE;
     if (e == Curve::LINEAR)
-        return std::string("LINEAR");
+        return luaEnumString_CurveInterpolationType_LINEAR;
     if (e == Curve::SMOOTH)
-        return std::string("SMOOTH");
+        return luaEnumString_CurveInterpolationType_SMOOTH;
     if (e == Curve::STEP)
-        return std::string("STEP");
+        return luaEnumString_CurveInterpolationType_STEP;
     if (e == Curve::QUADRATIC_IN)
-        return std::string("QUADRATIC_IN");
+        return luaEnumString_CurveInterpolationType_QUADRATIC_IN;
     if (e == Curve::QUADRATIC_OUT)
-        return std::string("QUADRATIC_OUT");
+        return luaEnumString_CurveInterpolationType_QUADRATIC_OUT;
     if (e == Curve::QUADRATIC_IN_OUT)
-        return std::string("QUADRATIC_IN_OUT");
+        return luaEnumString_CurveInterpolationType_QUADRATIC_IN_OUT;
     if (e == Curve::QUADRATIC_OUT_IN)
-        return std::string("QUADRATIC_OUT_IN");
+        return luaEnumString_CurveInterpolationType_QUADRATIC_OUT_IN;
     if (e == Curve::CUBIC_IN)
-        return std::string("CUBIC_IN");
+        return luaEnumString_CurveInterpolationType_CUBIC_IN;
     if (e == Curve::CUBIC_OUT)
-        return std::string("CUBIC_OUT");
+        return luaEnumString_CurveInterpolationType_CUBIC_OUT;
     if (e == Curve::CUBIC_IN_OUT)
-        return std::string("CUBIC_IN_OUT");
+        return luaEnumString_CurveInterpolationType_CUBIC_IN_OUT;
     if (e == Curve::CUBIC_OUT_IN)
-        return std::string("CUBIC_OUT_IN");
+        return luaEnumString_CurveInterpolationType_CUBIC_OUT_IN;
     if (e == Curve::QUARTIC_IN)
-        return std::string("QUARTIC_IN");
+        return luaEnumString_CurveInterpolationType_QUARTIC_IN;
     if (e == Curve::QUARTIC_OUT)
-        return std::string("QUARTIC_OUT");
+        return luaEnumString_CurveInterpolationType_QUARTIC_OUT;
     if (e == Curve::QUARTIC_IN_OUT)
-        return std::string("QUARTIC_IN_OUT");
+        return luaEnumString_CurveInterpolationType_QUARTIC_IN_OUT;
     if (e == Curve::QUARTIC_OUT_IN)
-        return std::string("QUARTIC_OUT_IN");
+        return luaEnumString_CurveInterpolationType_QUARTIC_OUT_IN;
     if (e == Curve::QUINTIC_IN)
-        return std::string("QUINTIC_IN");
+        return luaEnumString_CurveInterpolationType_QUINTIC_IN;
     if (e == Curve::QUINTIC_OUT)
-        return std::string("QUINTIC_OUT");
+        return luaEnumString_CurveInterpolationType_QUINTIC_OUT;
     if (e == Curve::QUINTIC_IN_OUT)
-        return std::string("QUINTIC_IN_OUT");
+        return luaEnumString_CurveInterpolationType_QUINTIC_IN_OUT;
     if (e == Curve::QUINTIC_OUT_IN)
-        return std::string("QUINTIC_OUT_IN");
+        return luaEnumString_CurveInterpolationType_QUINTIC_OUT_IN;
     if (e == Curve::SINE_IN)
-        return std::string("SINE_IN");
+        return luaEnumString_CurveInterpolationType_SINE_IN;
     if (e == Curve::SINE_OUT)
-        return std::string("SINE_OUT");
+        return luaEnumString_CurveInterpolationType_SINE_OUT;
     if (e == Curve::SINE_IN_OUT)
-        return std::string("SINE_IN_OUT");
+        return luaEnumString_CurveInterpolationType_SINE_IN_OUT;
     if (e == Curve::SINE_OUT_IN)
-        return std::string("SINE_OUT_IN");
+        return luaEnumString_CurveInterpolationType_SINE_OUT_IN;
     if (e == Curve::EXPONENTIAL_IN)
-        return std::string("EXPONENTIAL_IN");
+        return luaEnumString_CurveInterpolationType_EXPONENTIAL_IN;
     if (e == Curve::EXPONENTIAL_OUT)
-        return std::string("EXPONENTIAL_OUT");
+        return luaEnumString_CurveInterpolationType_EXPONENTIAL_OUT;
     if (e == Curve::EXPONENTIAL_IN_OUT)
-        return std::string("EXPONENTIAL_IN_OUT");
+        return luaEnumString_CurveInterpolationType_EXPONENTIAL_IN_OUT;
     if (e == Curve::EXPONENTIAL_OUT_IN)
-        return std::string("EXPONENTIAL_OUT_IN");
+        return luaEnumString_CurveInterpolationType_EXPONENTIAL_OUT_IN;
     if (e == Curve::CIRCULAR_IN)
-        return std::string("CIRCULAR_IN");
+        return luaEnumString_CurveInterpolationType_CIRCULAR_IN;
     if (e == Curve::CIRCULAR_OUT)
-        return std::string("CIRCULAR_OUT");
+        return luaEnumString_CurveInterpolationType_CIRCULAR_OUT;
     if (e == Curve::CIRCULAR_IN_OUT)
-        return std::string("CIRCULAR_IN_OUT");
+        return luaEnumString_CurveInterpolationType_CIRCULAR_IN_OUT;
     if (e == Curve::CIRCULAR_OUT_IN)
-        return std::string("CIRCULAR_OUT_IN");
+        return luaEnumString_CurveInterpolationType_CIRCULAR_OUT_IN;
     if (e == Curve::ELASTIC_IN)
-        return std::string("ELASTIC_IN");
+        return luaEnumString_CurveInterpolationType_ELASTIC_IN;
     if (e == Curve::ELASTIC_OUT)
-        return std::string("ELASTIC_OUT");
+        return luaEnumString_CurveInterpolationType_ELASTIC_OUT;
     if (e == Curve::ELASTIC_IN_OUT)
-        return std::string("ELASTIC_IN_OUT");
+        return luaEnumString_CurveInterpolationType_ELASTIC_IN_OUT;
     if (e == Curve::ELASTIC_OUT_IN)
-        return std::string("ELASTIC_OUT_IN");
+        return luaEnumString_CurveInterpolationType_ELASTIC_OUT_IN;
     if (e == Curve::OVERSHOOT_IN)
-        return std::string("OVERSHOOT_IN");
+        return luaEnumString_CurveInterpolationType_OVERSHOOT_IN;
     if (e == Curve::OVERSHOOT_OUT)
-        return std::string("OVERSHOOT_OUT");
+        return luaEnumString_CurveInterpolationType_OVERSHOOT_OUT;
     if (e == Curve::OVERSHOOT_IN_OUT)
-        return std::string("OVERSHOOT_IN_OUT");
+        return luaEnumString_CurveInterpolationType_OVERSHOOT_IN_OUT;
     if (e == Curve::OVERSHOOT_OUT_IN)
-        return std::string("OVERSHOOT_OUT_IN");
+        return luaEnumString_CurveInterpolationType_OVERSHOOT_OUT_IN;
     if (e == Curve::BOUNCE_IN)
-        return std::string("BOUNCE_IN");
+        return luaEnumString_CurveInterpolationType_BOUNCE_IN;
     if (e == Curve::BOUNCE_OUT)
-        return std::string("BOUNCE_OUT");
+        return luaEnumString_CurveInterpolationType_BOUNCE_OUT;
     if (e == Curve::BOUNCE_IN_OUT)
-        return std::string("BOUNCE_IN_OUT");
+        return luaEnumString_CurveInterpolationType_BOUNCE_IN_OUT;
     if (e == Curve::BOUNCE_OUT_IN)
-        return std::string("BOUNCE_OUT_IN");
+        return luaEnumString_CurveInterpolationType_BOUNCE_OUT_IN;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Curve::InterpolationType.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_DepthStencilTargetFormat_DEPTH = "DEPTH";
+static const char* luaEnumString_DepthStencilTargetFormat_DEPTH_STENCIL = "DEPTH_STENCIL";
+
 DepthStencilTarget::Format lua_enumFromString_DepthStencilTargetFormat(const char* s)
 {
-    if (strcmp(s, "DEPTH") == 0)
+    if (strcmp(s, luaEnumString_DepthStencilTargetFormat_DEPTH) == 0)
         return DepthStencilTarget::DEPTH;
-    if (strcmp(s, "DEPTH_STENCIL") == 0)
+    if (strcmp(s, luaEnumString_DepthStencilTargetFormat_DEPTH_STENCIL) == 0)
         return DepthStencilTarget::DEPTH_STENCIL;
     GP_ERROR("Invalid enumeration value '%s' for enumeration DepthStencilTarget::Format.", s);
     return DepthStencilTarget::DEPTH;
 }
 
-std::string lua_stringFromEnum_DepthStencilTargetFormat(DepthStencilTarget::Format e)
+const char* lua_stringFromEnum_DepthStencilTargetFormat(DepthStencilTarget::Format e)
 {
     if (e == DepthStencilTarget::DEPTH)
-        return std::string("DEPTH");
+        return luaEnumString_DepthStencilTargetFormat_DEPTH;
     if (e == DepthStencilTarget::DEPTH_STENCIL)
-        return std::string("DEPTH_STENCIL");
+        return luaEnumString_DepthStencilTargetFormat_DEPTH_STENCIL;
     GP_ERROR("Invalid enumeration value '%d' for enumeration DepthStencilTarget::Format.", e);
-    return std::string();
-}
+    return enumStringEmpty;
+}
+
+static const char* luaEnumString_FontJustify_ALIGN_LEFT = "ALIGN_LEFT";
+static const char* luaEnumString_FontJustify_ALIGN_HCENTER = "ALIGN_HCENTER";
+static const char* luaEnumString_FontJustify_ALIGN_RIGHT = "ALIGN_RIGHT";
+static const char* luaEnumString_FontJustify_ALIGN_TOP = "ALIGN_TOP";
+static const char* luaEnumString_FontJustify_ALIGN_VCENTER = "ALIGN_VCENTER";
+static const char* luaEnumString_FontJustify_ALIGN_BOTTOM = "ALIGN_BOTTOM";
+static const char* luaEnumString_FontJustify_ALIGN_TOP_LEFT = "ALIGN_TOP_LEFT";
+static const char* luaEnumString_FontJustify_ALIGN_VCENTER_LEFT = "ALIGN_VCENTER_LEFT";
+static const char* luaEnumString_FontJustify_ALIGN_BOTTOM_LEFT = "ALIGN_BOTTOM_LEFT";
+static const char* luaEnumString_FontJustify_ALIGN_TOP_HCENTER = "ALIGN_TOP_HCENTER";
+static const char* luaEnumString_FontJustify_ALIGN_VCENTER_HCENTER = "ALIGN_VCENTER_HCENTER";
+static const char* luaEnumString_FontJustify_ALIGN_BOTTOM_HCENTER = "ALIGN_BOTTOM_HCENTER";
+static const char* luaEnumString_FontJustify_ALIGN_TOP_RIGHT = "ALIGN_TOP_RIGHT";
+static const char* luaEnumString_FontJustify_ALIGN_VCENTER_RIGHT = "ALIGN_VCENTER_RIGHT";
+static const char* luaEnumString_FontJustify_ALIGN_BOTTOM_RIGHT = "ALIGN_BOTTOM_RIGHT";
 
 Font::Justify lua_enumFromString_FontJustify(const char* s)
 {
-    if (strcmp(s, "ALIGN_LEFT") == 0)
+    if (strcmp(s, luaEnumString_FontJustify_ALIGN_LEFT) == 0)
         return Font::ALIGN_LEFT;
-    if (strcmp(s, "ALIGN_HCENTER") == 0)
+    if (strcmp(s, luaEnumString_FontJustify_ALIGN_HCENTER) == 0)
         return Font::ALIGN_HCENTER;
-    if (strcmp(s, "ALIGN_RIGHT") == 0)
+    if (strcmp(s, luaEnumString_FontJustify_ALIGN_RIGHT) == 0)
         return Font::ALIGN_RIGHT;
-    if (strcmp(s, "ALIGN_TOP") == 0)
+    if (strcmp(s, luaEnumString_FontJustify_ALIGN_TOP) == 0)
         return Font::ALIGN_TOP;
-    if (strcmp(s, "ALIGN_VCENTER") == 0)
+    if (strcmp(s, luaEnumString_FontJustify_ALIGN_VCENTER) == 0)
         return Font::ALIGN_VCENTER;
-    if (strcmp(s, "ALIGN_BOTTOM") == 0)
+    if (strcmp(s, luaEnumString_FontJustify_ALIGN_BOTTOM) == 0)
         return Font::ALIGN_BOTTOM;
-    if (strcmp(s, "ALIGN_TOP_LEFT") == 0)
+    if (strcmp(s, luaEnumString_FontJustify_ALIGN_TOP_LEFT) == 0)
         return Font::ALIGN_TOP_LEFT;
-    if (strcmp(s, "ALIGN_VCENTER_LEFT") == 0)
+    if (strcmp(s, luaEnumString_FontJustify_ALIGN_VCENTER_LEFT) == 0)
         return Font::ALIGN_VCENTER_LEFT;
-    if (strcmp(s, "ALIGN_BOTTOM_LEFT") == 0)
+    if (strcmp(s, luaEnumString_FontJustify_ALIGN_BOTTOM_LEFT) == 0)
         return Font::ALIGN_BOTTOM_LEFT;
-    if (strcmp(s, "ALIGN_TOP_HCENTER") == 0)
+    if (strcmp(s, luaEnumString_FontJustify_ALIGN_TOP_HCENTER) == 0)
         return Font::ALIGN_TOP_HCENTER;
-    if (strcmp(s, "ALIGN_VCENTER_HCENTER") == 0)
+    if (strcmp(s, luaEnumString_FontJustify_ALIGN_VCENTER_HCENTER) == 0)
         return Font::ALIGN_VCENTER_HCENTER;
-    if (strcmp(s, "ALIGN_BOTTOM_HCENTER") == 0)
+    if (strcmp(s, luaEnumString_FontJustify_ALIGN_BOTTOM_HCENTER) == 0)
         return Font::ALIGN_BOTTOM_HCENTER;
-    if (strcmp(s, "ALIGN_TOP_RIGHT") == 0)
+    if (strcmp(s, luaEnumString_FontJustify_ALIGN_TOP_RIGHT) == 0)
         return Font::ALIGN_TOP_RIGHT;
-    if (strcmp(s, "ALIGN_VCENTER_RIGHT") == 0)
+    if (strcmp(s, luaEnumString_FontJustify_ALIGN_VCENTER_RIGHT) == 0)
         return Font::ALIGN_VCENTER_RIGHT;
-    if (strcmp(s, "ALIGN_BOTTOM_RIGHT") == 0)
+    if (strcmp(s, luaEnumString_FontJustify_ALIGN_BOTTOM_RIGHT) == 0)
         return Font::ALIGN_BOTTOM_RIGHT;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Font::Justify.", s);
     return Font::ALIGN_LEFT;
 }
 
-std::string lua_stringFromEnum_FontJustify(Font::Justify e)
+const char* lua_stringFromEnum_FontJustify(Font::Justify e)
 {
     if (e == Font::ALIGN_LEFT)
-        return std::string("ALIGN_LEFT");
+        return luaEnumString_FontJustify_ALIGN_LEFT;
     if (e == Font::ALIGN_HCENTER)
-        return std::string("ALIGN_HCENTER");
+        return luaEnumString_FontJustify_ALIGN_HCENTER;
     if (e == Font::ALIGN_RIGHT)
-        return std::string("ALIGN_RIGHT");
+        return luaEnumString_FontJustify_ALIGN_RIGHT;
     if (e == Font::ALIGN_TOP)
-        return std::string("ALIGN_TOP");
+        return luaEnumString_FontJustify_ALIGN_TOP;
     if (e == Font::ALIGN_VCENTER)
-        return std::string("ALIGN_VCENTER");
+        return luaEnumString_FontJustify_ALIGN_VCENTER;
     if (e == Font::ALIGN_BOTTOM)
-        return std::string("ALIGN_BOTTOM");
+        return luaEnumString_FontJustify_ALIGN_BOTTOM;
     if (e == Font::ALIGN_TOP_LEFT)
-        return std::string("ALIGN_TOP_LEFT");
+        return luaEnumString_FontJustify_ALIGN_TOP_LEFT;
     if (e == Font::ALIGN_VCENTER_LEFT)
-        return std::string("ALIGN_VCENTER_LEFT");
+        return luaEnumString_FontJustify_ALIGN_VCENTER_LEFT;
     if (e == Font::ALIGN_BOTTOM_LEFT)
-        return std::string("ALIGN_BOTTOM_LEFT");
+        return luaEnumString_FontJustify_ALIGN_BOTTOM_LEFT;
     if (e == Font::ALIGN_TOP_HCENTER)
-        return std::string("ALIGN_TOP_HCENTER");
+        return luaEnumString_FontJustify_ALIGN_TOP_HCENTER;
     if (e == Font::ALIGN_VCENTER_HCENTER)
-        return std::string("ALIGN_VCENTER_HCENTER");
+        return luaEnumString_FontJustify_ALIGN_VCENTER_HCENTER;
     if (e == Font::ALIGN_BOTTOM_HCENTER)
-        return std::string("ALIGN_BOTTOM_HCENTER");
+        return luaEnumString_FontJustify_ALIGN_BOTTOM_HCENTER;
     if (e == Font::ALIGN_TOP_RIGHT)
-        return std::string("ALIGN_TOP_RIGHT");
+        return luaEnumString_FontJustify_ALIGN_TOP_RIGHT;
     if (e == Font::ALIGN_VCENTER_RIGHT)
-        return std::string("ALIGN_VCENTER_RIGHT");
+        return luaEnumString_FontJustify_ALIGN_VCENTER_RIGHT;
     if (e == Font::ALIGN_BOTTOM_RIGHT)
-        return std::string("ALIGN_BOTTOM_RIGHT");
+        return luaEnumString_FontJustify_ALIGN_BOTTOM_RIGHT;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Font::Justify.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_FontStyle_PLAIN = "PLAIN";
+static const char* luaEnumString_FontStyle_BOLD = "BOLD";
+static const char* luaEnumString_FontStyle_ITALIC = "ITALIC";
+static const char* luaEnumString_FontStyle_BOLD_ITALIC = "BOLD_ITALIC";
+
 Font::Style lua_enumFromString_FontStyle(const char* s)
 {
-    if (strcmp(s, "PLAIN") == 0)
+    if (strcmp(s, luaEnumString_FontStyle_PLAIN) == 0)
         return Font::PLAIN;
-    if (strcmp(s, "BOLD") == 0)
+    if (strcmp(s, luaEnumString_FontStyle_BOLD) == 0)
         return Font::BOLD;
-    if (strcmp(s, "ITALIC") == 0)
+    if (strcmp(s, luaEnumString_FontStyle_ITALIC) == 0)
         return Font::ITALIC;
-    if (strcmp(s, "BOLD_ITALIC") == 0)
+    if (strcmp(s, luaEnumString_FontStyle_BOLD_ITALIC) == 0)
         return Font::BOLD_ITALIC;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Font::Style.", s);
     return Font::PLAIN;
 }
 
-std::string lua_stringFromEnum_FontStyle(Font::Style e)
+const char* lua_stringFromEnum_FontStyle(Font::Style e)
 {
     if (e == Font::PLAIN)
-        return std::string("PLAIN");
+        return luaEnumString_FontStyle_PLAIN;
     if (e == Font::BOLD)
-        return std::string("BOLD");
+        return luaEnumString_FontStyle_BOLD;
     if (e == Font::ITALIC)
-        return std::string("ITALIC");
+        return luaEnumString_FontStyle_ITALIC;
     if (e == Font::BOLD_ITALIC)
-        return std::string("BOLD_ITALIC");
+        return luaEnumString_FontStyle_BOLD_ITALIC;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Font::Style.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_GameClearFlags_CLEAR_COLOR = "CLEAR_COLOR";
+static const char* luaEnumString_GameClearFlags_CLEAR_DEPTH = "CLEAR_DEPTH";
+static const char* luaEnumString_GameClearFlags_CLEAR_STENCIL = "CLEAR_STENCIL";
+static const char* luaEnumString_GameClearFlags_CLEAR_COLOR_DEPTH = "CLEAR_COLOR_DEPTH";
+static const char* luaEnumString_GameClearFlags_CLEAR_COLOR_STENCIL = "CLEAR_COLOR_STENCIL";
+static const char* luaEnumString_GameClearFlags_CLEAR_DEPTH_STENCIL = "CLEAR_DEPTH_STENCIL";
+static const char* luaEnumString_GameClearFlags_CLEAR_COLOR_DEPTH_STENCIL = "CLEAR_COLOR_DEPTH_STENCIL";
+
 Game::ClearFlags lua_enumFromString_GameClearFlags(const char* s)
 {
-    if (strcmp(s, "CLEAR_COLOR") == 0)
+    if (strcmp(s, luaEnumString_GameClearFlags_CLEAR_COLOR) == 0)
         return Game::CLEAR_COLOR;
-    if (strcmp(s, "CLEAR_DEPTH") == 0)
+    if (strcmp(s, luaEnumString_GameClearFlags_CLEAR_DEPTH) == 0)
         return Game::CLEAR_DEPTH;
-    if (strcmp(s, "CLEAR_STENCIL") == 0)
+    if (strcmp(s, luaEnumString_GameClearFlags_CLEAR_STENCIL) == 0)
         return Game::CLEAR_STENCIL;
-    if (strcmp(s, "CLEAR_COLOR_DEPTH") == 0)
+    if (strcmp(s, luaEnumString_GameClearFlags_CLEAR_COLOR_DEPTH) == 0)
         return Game::CLEAR_COLOR_DEPTH;
-    if (strcmp(s, "CLEAR_COLOR_STENCIL") == 0)
+    if (strcmp(s, luaEnumString_GameClearFlags_CLEAR_COLOR_STENCIL) == 0)
         return Game::CLEAR_COLOR_STENCIL;
-    if (strcmp(s, "CLEAR_DEPTH_STENCIL") == 0)
+    if (strcmp(s, luaEnumString_GameClearFlags_CLEAR_DEPTH_STENCIL) == 0)
         return Game::CLEAR_DEPTH_STENCIL;
-    if (strcmp(s, "CLEAR_COLOR_DEPTH_STENCIL") == 0)
+    if (strcmp(s, luaEnumString_GameClearFlags_CLEAR_COLOR_DEPTH_STENCIL) == 0)
         return Game::CLEAR_COLOR_DEPTH_STENCIL;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Game::ClearFlags.", s);
     return Game::CLEAR_COLOR;
 }
 
-std::string lua_stringFromEnum_GameClearFlags(Game::ClearFlags e)
+const char* lua_stringFromEnum_GameClearFlags(Game::ClearFlags e)
 {
     if (e == Game::CLEAR_COLOR)
-        return std::string("CLEAR_COLOR");
+        return luaEnumString_GameClearFlags_CLEAR_COLOR;
     if (e == Game::CLEAR_DEPTH)
-        return std::string("CLEAR_DEPTH");
+        return luaEnumString_GameClearFlags_CLEAR_DEPTH;
     if (e == Game::CLEAR_STENCIL)
-        return std::string("CLEAR_STENCIL");
+        return luaEnumString_GameClearFlags_CLEAR_STENCIL;
     if (e == Game::CLEAR_COLOR_DEPTH)
-        return std::string("CLEAR_COLOR_DEPTH");
+        return luaEnumString_GameClearFlags_CLEAR_COLOR_DEPTH;
     if (e == Game::CLEAR_COLOR_STENCIL)
-        return std::string("CLEAR_COLOR_STENCIL");
+        return luaEnumString_GameClearFlags_CLEAR_COLOR_STENCIL;
     if (e == Game::CLEAR_DEPTH_STENCIL)
-        return std::string("CLEAR_DEPTH_STENCIL");
+        return luaEnumString_GameClearFlags_CLEAR_DEPTH_STENCIL;
     if (e == Game::CLEAR_COLOR_DEPTH_STENCIL)
-        return std::string("CLEAR_COLOR_DEPTH_STENCIL");
+        return luaEnumString_GameClearFlags_CLEAR_COLOR_DEPTH_STENCIL;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Game::ClearFlags.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_GameState_UNINITIALIZED = "UNINITIALIZED";
+static const char* luaEnumString_GameState_RUNNING = "RUNNING";
+static const char* luaEnumString_GameState_PAUSED = "PAUSED";
+
 Game::State lua_enumFromString_GameState(const char* s)
 {
-    if (strcmp(s, "UNINITIALIZED") == 0)
+    if (strcmp(s, luaEnumString_GameState_UNINITIALIZED) == 0)
         return Game::UNINITIALIZED;
-    if (strcmp(s, "RUNNING") == 0)
+    if (strcmp(s, luaEnumString_GameState_RUNNING) == 0)
         return Game::RUNNING;
-    if (strcmp(s, "PAUSED") == 0)
+    if (strcmp(s, luaEnumString_GameState_PAUSED) == 0)
         return Game::PAUSED;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Game::State.", s);
     return Game::UNINITIALIZED;
 }
 
-std::string lua_stringFromEnum_GameState(Game::State e)
+const char* lua_stringFromEnum_GameState(Game::State e)
 {
     if (e == Game::UNINITIALIZED)
-        return std::string("UNINITIALIZED");
+        return luaEnumString_GameState_UNINITIALIZED;
     if (e == Game::RUNNING)
-        return std::string("RUNNING");
+        return luaEnumString_GameState_RUNNING;
     if (e == Game::PAUSED)
-        return std::string("PAUSED");
+        return luaEnumString_GameState_PAUSED;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Game::State.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_GamepadButtonState_BUTTON_PRESSED = "BUTTON_PRESSED";
+static const char* luaEnumString_GamepadButtonState_BUTTON_RELEASED = "BUTTON_RELEASED";
+
 Gamepad::ButtonState lua_enumFromString_GamepadButtonState(const char* s)
 {
-    if (strcmp(s, "BUTTON_PRESSED") == 0)
+    if (strcmp(s, luaEnumString_GamepadButtonState_BUTTON_PRESSED) == 0)
         return Gamepad::BUTTON_PRESSED;
-    if (strcmp(s, "BUTTON_RELEASED") == 0)
+    if (strcmp(s, luaEnumString_GamepadButtonState_BUTTON_RELEASED) == 0)
         return Gamepad::BUTTON_RELEASED;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Gamepad::ButtonState.", s);
     return Gamepad::BUTTON_PRESSED;
 }
 
-std::string lua_stringFromEnum_GamepadButtonState(Gamepad::ButtonState e)
+const char* lua_stringFromEnum_GamepadButtonState(Gamepad::ButtonState e)
 {
     if (e == Gamepad::BUTTON_PRESSED)
-        return std::string("BUTTON_PRESSED");
+        return luaEnumString_GamepadButtonState_BUTTON_PRESSED;
     if (e == Gamepad::BUTTON_RELEASED)
-        return std::string("BUTTON_RELEASED");
+        return luaEnumString_GamepadButtonState_BUTTON_RELEASED;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Gamepad::ButtonState.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_GamepadGamepadEvent_ATTACHED_EVENT = "ATTACHED_EVENT";
+static const char* luaEnumString_GamepadGamepadEvent_DETACHED_EVENT = "DETACHED_EVENT";
+
 Gamepad::GamepadEvent lua_enumFromString_GamepadGamepadEvent(const char* s)
 {
-    if (strcmp(s, "ATTACHED_EVENT") == 0)
+    if (strcmp(s, luaEnumString_GamepadGamepadEvent_ATTACHED_EVENT) == 0)
         return Gamepad::ATTACHED_EVENT;
-    if (strcmp(s, "DETACHED_EVENT") == 0)
+    if (strcmp(s, luaEnumString_GamepadGamepadEvent_DETACHED_EVENT) == 0)
         return Gamepad::DETACHED_EVENT;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Gamepad::GamepadEvent.", s);
     return Gamepad::ATTACHED_EVENT;
 }
 
-std::string lua_stringFromEnum_GamepadGamepadEvent(Gamepad::GamepadEvent e)
+const char* lua_stringFromEnum_GamepadGamepadEvent(Gamepad::GamepadEvent e)
 {
     if (e == Gamepad::ATTACHED_EVENT)
-        return std::string("ATTACHED_EVENT");
+        return luaEnumString_GamepadGamepadEvent_ATTACHED_EVENT;
     if (e == Gamepad::DETACHED_EVENT)
-        return std::string("DETACHED_EVENT");
+        return luaEnumString_GamepadGamepadEvent_DETACHED_EVENT;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Gamepad::GamepadEvent.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_ImageFormat_RGB = "RGB";
+static const char* luaEnumString_ImageFormat_RGBA = "RGBA";
+
 Image::Format lua_enumFromString_ImageFormat(const char* s)
 {
-    if (strcmp(s, "RGB") == 0)
+    if (strcmp(s, luaEnumString_ImageFormat_RGB) == 0)
         return Image::RGB;
-    if (strcmp(s, "RGBA") == 0)
+    if (strcmp(s, luaEnumString_ImageFormat_RGBA) == 0)
         return Image::RGBA;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Image::Format.", s);
     return Image::RGB;
 }
 
-std::string lua_stringFromEnum_ImageFormat(Image::Format e)
+const char* lua_stringFromEnum_ImageFormat(Image::Format e)
 {
     if (e == Image::RGB)
-        return std::string("RGB");
+        return luaEnumString_ImageFormat_RGB;
     if (e == Image::RGBA)
-        return std::string("RGBA");
+        return luaEnumString_ImageFormat_RGBA;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Image::Format.", e);
-    return std::string();
-}
+    return enumStringEmpty;
+}
+
+static const char* luaEnumString_KeyboardKey_KEY_NONE = "KEY_NONE";
+static const char* luaEnumString_KeyboardKey_KEY_PAUSE = "KEY_PAUSE";
+static const char* luaEnumString_KeyboardKey_KEY_SCROLL_LOCK = "KEY_SCROLL_LOCK";
+static const char* luaEnumString_KeyboardKey_KEY_PRINT = "KEY_PRINT";
+static const char* luaEnumString_KeyboardKey_KEY_SYSREQ = "KEY_SYSREQ";
+static const char* luaEnumString_KeyboardKey_KEY_BREAK = "KEY_BREAK";
+static const char* luaEnumString_KeyboardKey_KEY_ESCAPE = "KEY_ESCAPE";
+static const char* luaEnumString_KeyboardKey_KEY_BACKSPACE = "KEY_BACKSPACE";
+static const char* luaEnumString_KeyboardKey_KEY_TAB = "KEY_TAB";
+static const char* luaEnumString_KeyboardKey_KEY_BACK_TAB = "KEY_BACK_TAB";
+static const char* luaEnumString_KeyboardKey_KEY_RETURN = "KEY_RETURN";
+static const char* luaEnumString_KeyboardKey_KEY_CAPS_LOCK = "KEY_CAPS_LOCK";
+static const char* luaEnumString_KeyboardKey_KEY_SHIFT = "KEY_SHIFT";
+static const char* luaEnumString_KeyboardKey_KEY_CTRL = "KEY_CTRL";
+static const char* luaEnumString_KeyboardKey_KEY_ALT = "KEY_ALT";
+static const char* luaEnumString_KeyboardKey_KEY_MENU = "KEY_MENU";
+static const char* luaEnumString_KeyboardKey_KEY_HYPER = "KEY_HYPER";
+static const char* luaEnumString_KeyboardKey_KEY_INSERT = "KEY_INSERT";
+static const char* luaEnumString_KeyboardKey_KEY_HOME = "KEY_HOME";
+static const char* luaEnumString_KeyboardKey_KEY_PG_UP = "KEY_PG_UP";
+static const char* luaEnumString_KeyboardKey_KEY_DELETE = "KEY_DELETE";
+static const char* luaEnumString_KeyboardKey_KEY_END = "KEY_END";
+static const char* luaEnumString_KeyboardKey_KEY_PG_DOWN = "KEY_PG_DOWN";
+static const char* luaEnumString_KeyboardKey_KEY_LEFT_ARROW = "KEY_LEFT_ARROW";
+static const char* luaEnumString_KeyboardKey_KEY_RIGHT_ARROW = "KEY_RIGHT_ARROW";
+static const char* luaEnumString_KeyboardKey_KEY_UP_ARROW = "KEY_UP_ARROW";
+static const char* luaEnumString_KeyboardKey_KEY_DOWN_ARROW = "KEY_DOWN_ARROW";
+static const char* luaEnumString_KeyboardKey_KEY_NUM_LOCK = "KEY_NUM_LOCK";
+static const char* luaEnumString_KeyboardKey_KEY_KP_PLUS = "KEY_KP_PLUS";
+static const char* luaEnumString_KeyboardKey_KEY_KP_MINUS = "KEY_KP_MINUS";
+static const char* luaEnumString_KeyboardKey_KEY_KP_MULTIPLY = "KEY_KP_MULTIPLY";
+static const char* luaEnumString_KeyboardKey_KEY_KP_DIVIDE = "KEY_KP_DIVIDE";
+static const char* luaEnumString_KeyboardKey_KEY_KP_ENTER = "KEY_KP_ENTER";
+static const char* luaEnumString_KeyboardKey_KEY_KP_HOME = "KEY_KP_HOME";
+static const char* luaEnumString_KeyboardKey_KEY_KP_UP = "KEY_KP_UP";
+static const char* luaEnumString_KeyboardKey_KEY_KP_PG_UP = "KEY_KP_PG_UP";
+static const char* luaEnumString_KeyboardKey_KEY_KP_LEFT = "KEY_KP_LEFT";
+static const char* luaEnumString_KeyboardKey_KEY_KP_FIVE = "KEY_KP_FIVE";
+static const char* luaEnumString_KeyboardKey_KEY_KP_RIGHT = "KEY_KP_RIGHT";
+static const char* luaEnumString_KeyboardKey_KEY_KP_END = "KEY_KP_END";
+static const char* luaEnumString_KeyboardKey_KEY_KP_DOWN = "KEY_KP_DOWN";
+static const char* luaEnumString_KeyboardKey_KEY_KP_PG_DOWN = "KEY_KP_PG_DOWN";
+static const char* luaEnumString_KeyboardKey_KEY_KP_INSERT = "KEY_KP_INSERT";
+static const char* luaEnumString_KeyboardKey_KEY_KP_DELETE = "KEY_KP_DELETE";
+static const char* luaEnumString_KeyboardKey_KEY_F1 = "KEY_F1";
+static const char* luaEnumString_KeyboardKey_KEY_F2 = "KEY_F2";
+static const char* luaEnumString_KeyboardKey_KEY_F3 = "KEY_F3";
+static const char* luaEnumString_KeyboardKey_KEY_F4 = "KEY_F4";
+static const char* luaEnumString_KeyboardKey_KEY_F5 = "KEY_F5";
+static const char* luaEnumString_KeyboardKey_KEY_F6 = "KEY_F6";
+static const char* luaEnumString_KeyboardKey_KEY_F7 = "KEY_F7";
+static const char* luaEnumString_KeyboardKey_KEY_F8 = "KEY_F8";
+static const char* luaEnumString_KeyboardKey_KEY_F9 = "KEY_F9";
+static const char* luaEnumString_KeyboardKey_KEY_F10 = "KEY_F10";
+static const char* luaEnumString_KeyboardKey_KEY_F11 = "KEY_F11";
+static const char* luaEnumString_KeyboardKey_KEY_F12 = "KEY_F12";
+static const char* luaEnumString_KeyboardKey_KEY_SPACE = "KEY_SPACE";
+static const char* luaEnumString_KeyboardKey_KEY_EXCLAM = "KEY_EXCLAM";
+static const char* luaEnumString_KeyboardKey_KEY_QUOTE = "KEY_QUOTE";
+static const char* luaEnumString_KeyboardKey_KEY_NUMBER = "KEY_NUMBER";
+static const char* luaEnumString_KeyboardKey_KEY_DOLLAR = "KEY_DOLLAR";
+static const char* luaEnumString_KeyboardKey_KEY_PERCENT = "KEY_PERCENT";
+static const char* luaEnumString_KeyboardKey_KEY_CIRCUMFLEX = "KEY_CIRCUMFLEX";
+static const char* luaEnumString_KeyboardKey_KEY_AMPERSAND = "KEY_AMPERSAND";
+static const char* luaEnumString_KeyboardKey_KEY_APOSTROPHE = "KEY_APOSTROPHE";
+static const char* luaEnumString_KeyboardKey_KEY_LEFT_PARENTHESIS = "KEY_LEFT_PARENTHESIS";
+static const char* luaEnumString_KeyboardKey_KEY_RIGHT_PARENTHESIS = "KEY_RIGHT_PARENTHESIS";
+static const char* luaEnumString_KeyboardKey_KEY_ASTERISK = "KEY_ASTERISK";
+static const char* luaEnumString_KeyboardKey_KEY_PLUS = "KEY_PLUS";
+static const char* luaEnumString_KeyboardKey_KEY_COMMA = "KEY_COMMA";
+static const char* luaEnumString_KeyboardKey_KEY_MINUS = "KEY_MINUS";
+static const char* luaEnumString_KeyboardKey_KEY_PERIOD = "KEY_PERIOD";
+static const char* luaEnumString_KeyboardKey_KEY_SLASH = "KEY_SLASH";
+static const char* luaEnumString_KeyboardKey_KEY_ZERO = "KEY_ZERO";
+static const char* luaEnumString_KeyboardKey_KEY_ONE = "KEY_ONE";
+static const char* luaEnumString_KeyboardKey_KEY_TWO = "KEY_TWO";
+static const char* luaEnumString_KeyboardKey_KEY_THREE = "KEY_THREE";
+static const char* luaEnumString_KeyboardKey_KEY_FOUR = "KEY_FOUR";
+static const char* luaEnumString_KeyboardKey_KEY_FIVE = "KEY_FIVE";
+static const char* luaEnumString_KeyboardKey_KEY_SIX = "KEY_SIX";
+static const char* luaEnumString_KeyboardKey_KEY_SEVEN = "KEY_SEVEN";
+static const char* luaEnumString_KeyboardKey_KEY_EIGHT = "KEY_EIGHT";
+static const char* luaEnumString_KeyboardKey_KEY_NINE = "KEY_NINE";
+static const char* luaEnumString_KeyboardKey_KEY_COLON = "KEY_COLON";
+static const char* luaEnumString_KeyboardKey_KEY_SEMICOLON = "KEY_SEMICOLON";
+static const char* luaEnumString_KeyboardKey_KEY_LESS_THAN = "KEY_LESS_THAN";
+static const char* luaEnumString_KeyboardKey_KEY_EQUAL = "KEY_EQUAL";
+static const char* luaEnumString_KeyboardKey_KEY_GREATER_THAN = "KEY_GREATER_THAN";
+static const char* luaEnumString_KeyboardKey_KEY_QUESTION = "KEY_QUESTION";
+static const char* luaEnumString_KeyboardKey_KEY_AT = "KEY_AT";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_A = "KEY_CAPITAL_A";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_B = "KEY_CAPITAL_B";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_C = "KEY_CAPITAL_C";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_D = "KEY_CAPITAL_D";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_E = "KEY_CAPITAL_E";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_F = "KEY_CAPITAL_F";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_G = "KEY_CAPITAL_G";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_H = "KEY_CAPITAL_H";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_I = "KEY_CAPITAL_I";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_J = "KEY_CAPITAL_J";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_K = "KEY_CAPITAL_K";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_L = "KEY_CAPITAL_L";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_M = "KEY_CAPITAL_M";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_N = "KEY_CAPITAL_N";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_O = "KEY_CAPITAL_O";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_P = "KEY_CAPITAL_P";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_Q = "KEY_CAPITAL_Q";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_R = "KEY_CAPITAL_R";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_S = "KEY_CAPITAL_S";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_T = "KEY_CAPITAL_T";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_U = "KEY_CAPITAL_U";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_V = "KEY_CAPITAL_V";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_W = "KEY_CAPITAL_W";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_X = "KEY_CAPITAL_X";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_Y = "KEY_CAPITAL_Y";
+static const char* luaEnumString_KeyboardKey_KEY_CAPITAL_Z = "KEY_CAPITAL_Z";
+static const char* luaEnumString_KeyboardKey_KEY_LEFT_BRACKET = "KEY_LEFT_BRACKET";
+static const char* luaEnumString_KeyboardKey_KEY_BACK_SLASH = "KEY_BACK_SLASH";
+static const char* luaEnumString_KeyboardKey_KEY_RIGHT_BRACKET = "KEY_RIGHT_BRACKET";
+static const char* luaEnumString_KeyboardKey_KEY_UNDERSCORE = "KEY_UNDERSCORE";
+static const char* luaEnumString_KeyboardKey_KEY_GRAVE = "KEY_GRAVE";
+static const char* luaEnumString_KeyboardKey_KEY_A = "KEY_A";
+static const char* luaEnumString_KeyboardKey_KEY_B = "KEY_B";
+static const char* luaEnumString_KeyboardKey_KEY_C = "KEY_C";
+static const char* luaEnumString_KeyboardKey_KEY_D = "KEY_D";
+static const char* luaEnumString_KeyboardKey_KEY_E = "KEY_E";
+static const char* luaEnumString_KeyboardKey_KEY_F = "KEY_F";
+static const char* luaEnumString_KeyboardKey_KEY_G = "KEY_G";
+static const char* luaEnumString_KeyboardKey_KEY_H = "KEY_H";
+static const char* luaEnumString_KeyboardKey_KEY_I = "KEY_I";
+static const char* luaEnumString_KeyboardKey_KEY_J = "KEY_J";
+static const char* luaEnumString_KeyboardKey_KEY_K = "KEY_K";
+static const char* luaEnumString_KeyboardKey_KEY_L = "KEY_L";
+static const char* luaEnumString_KeyboardKey_KEY_M = "KEY_M";
+static const char* luaEnumString_KeyboardKey_KEY_N = "KEY_N";
+static const char* luaEnumString_KeyboardKey_KEY_O = "KEY_O";
+static const char* luaEnumString_KeyboardKey_KEY_P = "KEY_P";
+static const char* luaEnumString_KeyboardKey_KEY_Q = "KEY_Q";
+static const char* luaEnumString_KeyboardKey_KEY_R = "KEY_R";
+static const char* luaEnumString_KeyboardKey_KEY_S = "KEY_S";
+static const char* luaEnumString_KeyboardKey_KEY_T = "KEY_T";
+static const char* luaEnumString_KeyboardKey_KEY_U = "KEY_U";
+static const char* luaEnumString_KeyboardKey_KEY_V = "KEY_V";
+static const char* luaEnumString_KeyboardKey_KEY_W = "KEY_W";
+static const char* luaEnumString_KeyboardKey_KEY_X = "KEY_X";
+static const char* luaEnumString_KeyboardKey_KEY_Y = "KEY_Y";
+static const char* luaEnumString_KeyboardKey_KEY_Z = "KEY_Z";
+static const char* luaEnumString_KeyboardKey_KEY_LEFT_BRACE = "KEY_LEFT_BRACE";
+static const char* luaEnumString_KeyboardKey_KEY_BAR = "KEY_BAR";
+static const char* luaEnumString_KeyboardKey_KEY_RIGHT_BRACE = "KEY_RIGHT_BRACE";
+static const char* luaEnumString_KeyboardKey_KEY_TILDE = "KEY_TILDE";
+static const char* luaEnumString_KeyboardKey_KEY_EURO = "KEY_EURO";
+static const char* luaEnumString_KeyboardKey_KEY_POUND = "KEY_POUND";
+static const char* luaEnumString_KeyboardKey_KEY_YEN = "KEY_YEN";
+static const char* luaEnumString_KeyboardKey_KEY_MIDDLE_DOT = "KEY_MIDDLE_DOT";
+static const char* luaEnumString_KeyboardKey_KEY_SEARCH = "KEY_SEARCH";
 
 Keyboard::Key lua_enumFromString_KeyboardKey(const char* s)
 {
-    if (strcmp(s, "KEY_NONE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_NONE) == 0)
         return Keyboard::KEY_NONE;
-    if (strcmp(s, "KEY_PAUSE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_PAUSE) == 0)
         return Keyboard::KEY_PAUSE;
-    if (strcmp(s, "KEY_SCROLL_LOCK") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_SCROLL_LOCK) == 0)
         return Keyboard::KEY_SCROLL_LOCK;
-    if (strcmp(s, "KEY_PRINT") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_PRINT) == 0)
         return Keyboard::KEY_PRINT;
-    if (strcmp(s, "KEY_SYSREQ") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_SYSREQ) == 0)
         return Keyboard::KEY_SYSREQ;
-    if (strcmp(s, "KEY_BREAK") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_BREAK) == 0)
         return Keyboard::KEY_BREAK;
-    if (strcmp(s, "KEY_ESCAPE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_ESCAPE) == 0)
         return Keyboard::KEY_ESCAPE;
-    if (strcmp(s, "KEY_BACKSPACE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_BACKSPACE) == 0)
         return Keyboard::KEY_BACKSPACE;
-    if (strcmp(s, "KEY_TAB") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_TAB) == 0)
         return Keyboard::KEY_TAB;
-    if (strcmp(s, "KEY_BACK_TAB") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_BACK_TAB) == 0)
         return Keyboard::KEY_BACK_TAB;
-    if (strcmp(s, "KEY_RETURN") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_RETURN) == 0)
         return Keyboard::KEY_RETURN;
-    if (strcmp(s, "KEY_CAPS_LOCK") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPS_LOCK) == 0)
         return Keyboard::KEY_CAPS_LOCK;
-    if (strcmp(s, "KEY_SHIFT") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_SHIFT) == 0)
         return Keyboard::KEY_SHIFT;
-    if (strcmp(s, "KEY_CTRL") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CTRL) == 0)
         return Keyboard::KEY_CTRL;
-    if (strcmp(s, "KEY_ALT") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_ALT) == 0)
         return Keyboard::KEY_ALT;
-    if (strcmp(s, "KEY_MENU") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_MENU) == 0)
         return Keyboard::KEY_MENU;
-    if (strcmp(s, "KEY_HYPER") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_HYPER) == 0)
         return Keyboard::KEY_HYPER;
-    if (strcmp(s, "KEY_INSERT") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_INSERT) == 0)
         return Keyboard::KEY_INSERT;
-    if (strcmp(s, "KEY_HOME") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_HOME) == 0)
         return Keyboard::KEY_HOME;
-    if (strcmp(s, "KEY_PG_UP") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_PG_UP) == 0)
         return Keyboard::KEY_PG_UP;
-    if (strcmp(s, "KEY_DELETE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_DELETE) == 0)
         return Keyboard::KEY_DELETE;
-    if (strcmp(s, "KEY_END") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_END) == 0)
         return Keyboard::KEY_END;
-    if (strcmp(s, "KEY_PG_DOWN") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_PG_DOWN) == 0)
         return Keyboard::KEY_PG_DOWN;
-    if (strcmp(s, "KEY_LEFT_ARROW") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_LEFT_ARROW) == 0)
         return Keyboard::KEY_LEFT_ARROW;
-    if (strcmp(s, "KEY_RIGHT_ARROW") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_RIGHT_ARROW) == 0)
         return Keyboard::KEY_RIGHT_ARROW;
-    if (strcmp(s, "KEY_UP_ARROW") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_UP_ARROW) == 0)
         return Keyboard::KEY_UP_ARROW;
-    if (strcmp(s, "KEY_DOWN_ARROW") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_DOWN_ARROW) == 0)
         return Keyboard::KEY_DOWN_ARROW;
-    if (strcmp(s, "KEY_NUM_LOCK") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_NUM_LOCK) == 0)
         return Keyboard::KEY_NUM_LOCK;
-    if (strcmp(s, "KEY_KP_PLUS") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_KP_PLUS) == 0)
         return Keyboard::KEY_KP_PLUS;
-    if (strcmp(s, "KEY_KP_MINUS") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_KP_MINUS) == 0)
         return Keyboard::KEY_KP_MINUS;
-    if (strcmp(s, "KEY_KP_MULTIPLY") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_KP_MULTIPLY) == 0)
         return Keyboard::KEY_KP_MULTIPLY;
-    if (strcmp(s, "KEY_KP_DIVIDE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_KP_DIVIDE) == 0)
         return Keyboard::KEY_KP_DIVIDE;
-    if (strcmp(s, "KEY_KP_ENTER") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_KP_ENTER) == 0)
         return Keyboard::KEY_KP_ENTER;
-    if (strcmp(s, "KEY_KP_HOME") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_KP_HOME) == 0)
         return Keyboard::KEY_KP_HOME;
-    if (strcmp(s, "KEY_KP_UP") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_KP_UP) == 0)
         return Keyboard::KEY_KP_UP;
-    if (strcmp(s, "KEY_KP_PG_UP") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_KP_PG_UP) == 0)
         return Keyboard::KEY_KP_PG_UP;
-    if (strcmp(s, "KEY_KP_LEFT") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_KP_LEFT) == 0)
         return Keyboard::KEY_KP_LEFT;
-    if (strcmp(s, "KEY_KP_FIVE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_KP_FIVE) == 0)
         return Keyboard::KEY_KP_FIVE;
-    if (strcmp(s, "KEY_KP_RIGHT") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_KP_RIGHT) == 0)
         return Keyboard::KEY_KP_RIGHT;
-    if (strcmp(s, "KEY_KP_END") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_KP_END) == 0)
         return Keyboard::KEY_KP_END;
-    if (strcmp(s, "KEY_KP_DOWN") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_KP_DOWN) == 0)
         return Keyboard::KEY_KP_DOWN;
-    if (strcmp(s, "KEY_KP_PG_DOWN") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_KP_PG_DOWN) == 0)
         return Keyboard::KEY_KP_PG_DOWN;
-    if (strcmp(s, "KEY_KP_INSERT") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_KP_INSERT) == 0)
         return Keyboard::KEY_KP_INSERT;
-    if (strcmp(s, "KEY_KP_DELETE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_KP_DELETE) == 0)
         return Keyboard::KEY_KP_DELETE;
-    if (strcmp(s, "KEY_F1") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_F1) == 0)
         return Keyboard::KEY_F1;
-    if (strcmp(s, "KEY_F2") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_F2) == 0)
         return Keyboard::KEY_F2;
-    if (strcmp(s, "KEY_F3") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_F3) == 0)
         return Keyboard::KEY_F3;
-    if (strcmp(s, "KEY_F4") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_F4) == 0)
         return Keyboard::KEY_F4;
-    if (strcmp(s, "KEY_F5") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_F5) == 0)
         return Keyboard::KEY_F5;
-    if (strcmp(s, "KEY_F6") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_F6) == 0)
         return Keyboard::KEY_F6;
-    if (strcmp(s, "KEY_F7") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_F7) == 0)
         return Keyboard::KEY_F7;
-    if (strcmp(s, "KEY_F8") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_F8) == 0)
         return Keyboard::KEY_F8;
-    if (strcmp(s, "KEY_F9") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_F9) == 0)
         return Keyboard::KEY_F9;
-    if (strcmp(s, "KEY_F10") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_F10) == 0)
         return Keyboard::KEY_F10;
-    if (strcmp(s, "KEY_F11") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_F11) == 0)
         return Keyboard::KEY_F11;
-    if (strcmp(s, "KEY_F12") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_F12) == 0)
         return Keyboard::KEY_F12;
-    if (strcmp(s, "KEY_SPACE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_SPACE) == 0)
         return Keyboard::KEY_SPACE;
-    if (strcmp(s, "KEY_EXCLAM") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_EXCLAM) == 0)
         return Keyboard::KEY_EXCLAM;
-    if (strcmp(s, "KEY_QUOTE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_QUOTE) == 0)
         return Keyboard::KEY_QUOTE;
-    if (strcmp(s, "KEY_NUMBER") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_NUMBER) == 0)
         return Keyboard::KEY_NUMBER;
-    if (strcmp(s, "KEY_DOLLAR") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_DOLLAR) == 0)
         return Keyboard::KEY_DOLLAR;
-    if (strcmp(s, "KEY_PERCENT") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_PERCENT) == 0)
         return Keyboard::KEY_PERCENT;
-    if (strcmp(s, "KEY_CIRCUMFLEX") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CIRCUMFLEX) == 0)
         return Keyboard::KEY_CIRCUMFLEX;
-    if (strcmp(s, "KEY_AMPERSAND") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_AMPERSAND) == 0)
         return Keyboard::KEY_AMPERSAND;
-    if (strcmp(s, "KEY_APOSTROPHE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_APOSTROPHE) == 0)
         return Keyboard::KEY_APOSTROPHE;
-    if (strcmp(s, "KEY_LEFT_PARENTHESIS") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_LEFT_PARENTHESIS) == 0)
         return Keyboard::KEY_LEFT_PARENTHESIS;
-    if (strcmp(s, "KEY_RIGHT_PARENTHESIS") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_RIGHT_PARENTHESIS) == 0)
         return Keyboard::KEY_RIGHT_PARENTHESIS;
-    if (strcmp(s, "KEY_ASTERISK") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_ASTERISK) == 0)
         return Keyboard::KEY_ASTERISK;
-    if (strcmp(s, "KEY_PLUS") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_PLUS) == 0)
         return Keyboard::KEY_PLUS;
-    if (strcmp(s, "KEY_COMMA") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_COMMA) == 0)
         return Keyboard::KEY_COMMA;
-    if (strcmp(s, "KEY_MINUS") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_MINUS) == 0)
         return Keyboard::KEY_MINUS;
-    if (strcmp(s, "KEY_PERIOD") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_PERIOD) == 0)
         return Keyboard::KEY_PERIOD;
-    if (strcmp(s, "KEY_SLASH") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_SLASH) == 0)
         return Keyboard::KEY_SLASH;
-    if (strcmp(s, "KEY_ZERO") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_ZERO) == 0)
         return Keyboard::KEY_ZERO;
-    if (strcmp(s, "KEY_ONE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_ONE) == 0)
         return Keyboard::KEY_ONE;
-    if (strcmp(s, "KEY_TWO") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_TWO) == 0)
         return Keyboard::KEY_TWO;
-    if (strcmp(s, "KEY_THREE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_THREE) == 0)
         return Keyboard::KEY_THREE;
-    if (strcmp(s, "KEY_FOUR") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_FOUR) == 0)
         return Keyboard::KEY_FOUR;
-    if (strcmp(s, "KEY_FIVE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_FIVE) == 0)
         return Keyboard::KEY_FIVE;
-    if (strcmp(s, "KEY_SIX") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_SIX) == 0)
         return Keyboard::KEY_SIX;
-    if (strcmp(s, "KEY_SEVEN") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_SEVEN) == 0)
         return Keyboard::KEY_SEVEN;
-    if (strcmp(s, "KEY_EIGHT") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_EIGHT) == 0)
         return Keyboard::KEY_EIGHT;
-    if (strcmp(s, "KEY_NINE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_NINE) == 0)
         return Keyboard::KEY_NINE;
-    if (strcmp(s, "KEY_COLON") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_COLON) == 0)
         return Keyboard::KEY_COLON;
-    if (strcmp(s, "KEY_SEMICOLON") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_SEMICOLON) == 0)
         return Keyboard::KEY_SEMICOLON;
-    if (strcmp(s, "KEY_LESS_THAN") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_LESS_THAN) == 0)
         return Keyboard::KEY_LESS_THAN;
-    if (strcmp(s, "KEY_EQUAL") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_EQUAL) == 0)
         return Keyboard::KEY_EQUAL;
-    if (strcmp(s, "KEY_GREATER_THAN") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_GREATER_THAN) == 0)
         return Keyboard::KEY_GREATER_THAN;
-    if (strcmp(s, "KEY_QUESTION") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_QUESTION) == 0)
         return Keyboard::KEY_QUESTION;
-    if (strcmp(s, "KEY_AT") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_AT) == 0)
         return Keyboard::KEY_AT;
-    if (strcmp(s, "KEY_CAPITAL_A") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_A) == 0)
         return Keyboard::KEY_CAPITAL_A;
-    if (strcmp(s, "KEY_CAPITAL_B") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_B) == 0)
         return Keyboard::KEY_CAPITAL_B;
-    if (strcmp(s, "KEY_CAPITAL_C") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_C) == 0)
         return Keyboard::KEY_CAPITAL_C;
-    if (strcmp(s, "KEY_CAPITAL_D") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_D) == 0)
         return Keyboard::KEY_CAPITAL_D;
-    if (strcmp(s, "KEY_CAPITAL_E") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_E) == 0)
         return Keyboard::KEY_CAPITAL_E;
-    if (strcmp(s, "KEY_CAPITAL_F") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_F) == 0)
         return Keyboard::KEY_CAPITAL_F;
-    if (strcmp(s, "KEY_CAPITAL_G") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_G) == 0)
         return Keyboard::KEY_CAPITAL_G;
-    if (strcmp(s, "KEY_CAPITAL_H") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_H) == 0)
         return Keyboard::KEY_CAPITAL_H;
-    if (strcmp(s, "KEY_CAPITAL_I") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_I) == 0)
         return Keyboard::KEY_CAPITAL_I;
-    if (strcmp(s, "KEY_CAPITAL_J") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_J) == 0)
         return Keyboard::KEY_CAPITAL_J;
-    if (strcmp(s, "KEY_CAPITAL_K") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_K) == 0)
         return Keyboard::KEY_CAPITAL_K;
-    if (strcmp(s, "KEY_CAPITAL_L") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_L) == 0)
         return Keyboard::KEY_CAPITAL_L;
-    if (strcmp(s, "KEY_CAPITAL_M") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_M) == 0)
         return Keyboard::KEY_CAPITAL_M;
-    if (strcmp(s, "KEY_CAPITAL_N") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_N) == 0)
         return Keyboard::KEY_CAPITAL_N;
-    if (strcmp(s, "KEY_CAPITAL_O") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_O) == 0)
         return Keyboard::KEY_CAPITAL_O;
-    if (strcmp(s, "KEY_CAPITAL_P") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_P) == 0)
         return Keyboard::KEY_CAPITAL_P;
-    if (strcmp(s, "KEY_CAPITAL_Q") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_Q) == 0)
         return Keyboard::KEY_CAPITAL_Q;
-    if (strcmp(s, "KEY_CAPITAL_R") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_R) == 0)
         return Keyboard::KEY_CAPITAL_R;
-    if (strcmp(s, "KEY_CAPITAL_S") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_S) == 0)
         return Keyboard::KEY_CAPITAL_S;
-    if (strcmp(s, "KEY_CAPITAL_T") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_T) == 0)
         return Keyboard::KEY_CAPITAL_T;
-    if (strcmp(s, "KEY_CAPITAL_U") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_U) == 0)
         return Keyboard::KEY_CAPITAL_U;
-    if (strcmp(s, "KEY_CAPITAL_V") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_V) == 0)
         return Keyboard::KEY_CAPITAL_V;
-    if (strcmp(s, "KEY_CAPITAL_W") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_W) == 0)
         return Keyboard::KEY_CAPITAL_W;
-    if (strcmp(s, "KEY_CAPITAL_X") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_X) == 0)
         return Keyboard::KEY_CAPITAL_X;
-    if (strcmp(s, "KEY_CAPITAL_Y") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_Y) == 0)
         return Keyboard::KEY_CAPITAL_Y;
-    if (strcmp(s, "KEY_CAPITAL_Z") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_CAPITAL_Z) == 0)
         return Keyboard::KEY_CAPITAL_Z;
-    if (strcmp(s, "KEY_LEFT_BRACKET") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_LEFT_BRACKET) == 0)
         return Keyboard::KEY_LEFT_BRACKET;
-    if (strcmp(s, "KEY_BACK_SLASH") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_BACK_SLASH) == 0)
         return Keyboard::KEY_BACK_SLASH;
-    if (strcmp(s, "KEY_RIGHT_BRACKET") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_RIGHT_BRACKET) == 0)
         return Keyboard::KEY_RIGHT_BRACKET;
-    if (strcmp(s, "KEY_UNDERSCORE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_UNDERSCORE) == 0)
         return Keyboard::KEY_UNDERSCORE;
-    if (strcmp(s, "KEY_GRAVE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_GRAVE) == 0)
         return Keyboard::KEY_GRAVE;
-    if (strcmp(s, "KEY_A") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_A) == 0)
         return Keyboard::KEY_A;
-    if (strcmp(s, "KEY_B") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_B) == 0)
         return Keyboard::KEY_B;
-    if (strcmp(s, "KEY_C") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_C) == 0)
         return Keyboard::KEY_C;
-    if (strcmp(s, "KEY_D") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_D) == 0)
         return Keyboard::KEY_D;
-    if (strcmp(s, "KEY_E") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_E) == 0)
         return Keyboard::KEY_E;
-    if (strcmp(s, "KEY_F") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_F) == 0)
         return Keyboard::KEY_F;
-    if (strcmp(s, "KEY_G") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_G) == 0)
         return Keyboard::KEY_G;
-    if (strcmp(s, "KEY_H") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_H) == 0)
         return Keyboard::KEY_H;
-    if (strcmp(s, "KEY_I") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_I) == 0)
         return Keyboard::KEY_I;
-    if (strcmp(s, "KEY_J") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_J) == 0)
         return Keyboard::KEY_J;
-    if (strcmp(s, "KEY_K") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_K) == 0)
         return Keyboard::KEY_K;
-    if (strcmp(s, "KEY_L") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_L) == 0)
         return Keyboard::KEY_L;
-    if (strcmp(s, "KEY_M") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_M) == 0)
         return Keyboard::KEY_M;
-    if (strcmp(s, "KEY_N") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_N) == 0)
         return Keyboard::KEY_N;
-    if (strcmp(s, "KEY_O") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_O) == 0)
         return Keyboard::KEY_O;
-    if (strcmp(s, "KEY_P") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_P) == 0)
         return Keyboard::KEY_P;
-    if (strcmp(s, "KEY_Q") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_Q) == 0)
         return Keyboard::KEY_Q;
-    if (strcmp(s, "KEY_R") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_R) == 0)
         return Keyboard::KEY_R;
-    if (strcmp(s, "KEY_S") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_S) == 0)
         return Keyboard::KEY_S;
-    if (strcmp(s, "KEY_T") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_T) == 0)
         return Keyboard::KEY_T;
-    if (strcmp(s, "KEY_U") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_U) == 0)
         return Keyboard::KEY_U;
-    if (strcmp(s, "KEY_V") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_V) == 0)
         return Keyboard::KEY_V;
-    if (strcmp(s, "KEY_W") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_W) == 0)
         return Keyboard::KEY_W;
-    if (strcmp(s, "KEY_X") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_X) == 0)
         return Keyboard::KEY_X;
-    if (strcmp(s, "KEY_Y") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_Y) == 0)
         return Keyboard::KEY_Y;
-    if (strcmp(s, "KEY_Z") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_Z) == 0)
         return Keyboard::KEY_Z;
-    if (strcmp(s, "KEY_LEFT_BRACE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_LEFT_BRACE) == 0)
         return Keyboard::KEY_LEFT_BRACE;
-    if (strcmp(s, "KEY_BAR") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_BAR) == 0)
         return Keyboard::KEY_BAR;
-    if (strcmp(s, "KEY_RIGHT_BRACE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_RIGHT_BRACE) == 0)
         return Keyboard::KEY_RIGHT_BRACE;
-    if (strcmp(s, "KEY_TILDE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_TILDE) == 0)
         return Keyboard::KEY_TILDE;
-    if (strcmp(s, "KEY_EURO") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_EURO) == 0)
         return Keyboard::KEY_EURO;
-    if (strcmp(s, "KEY_POUND") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_POUND) == 0)
         return Keyboard::KEY_POUND;
-    if (strcmp(s, "KEY_YEN") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_YEN) == 0)
         return Keyboard::KEY_YEN;
-    if (strcmp(s, "KEY_MIDDLE_DOT") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_MIDDLE_DOT) == 0)
         return Keyboard::KEY_MIDDLE_DOT;
-    if (strcmp(s, "KEY_SEARCH") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKey_KEY_SEARCH) == 0)
         return Keyboard::KEY_SEARCH;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Keyboard::Key.", s);
     return Keyboard::KEY_NONE;
 }
 
-std::string lua_stringFromEnum_KeyboardKey(Keyboard::Key e)
+const char* lua_stringFromEnum_KeyboardKey(Keyboard::Key e)
 {
     if (e == Keyboard::KEY_NONE)
-        return std::string("KEY_NONE");
+        return luaEnumString_KeyboardKey_KEY_NONE;
     if (e == Keyboard::KEY_PAUSE)
-        return std::string("KEY_PAUSE");
+        return luaEnumString_KeyboardKey_KEY_PAUSE;
     if (e == Keyboard::KEY_SCROLL_LOCK)
-        return std::string("KEY_SCROLL_LOCK");
+        return luaEnumString_KeyboardKey_KEY_SCROLL_LOCK;
     if (e == Keyboard::KEY_PRINT)
-        return std::string("KEY_PRINT");
+        return luaEnumString_KeyboardKey_KEY_PRINT;
     if (e == Keyboard::KEY_SYSREQ)
-        return std::string("KEY_SYSREQ");
+        return luaEnumString_KeyboardKey_KEY_SYSREQ;
     if (e == Keyboard::KEY_BREAK)
-        return std::string("KEY_BREAK");
+        return luaEnumString_KeyboardKey_KEY_BREAK;
     if (e == Keyboard::KEY_ESCAPE)
-        return std::string("KEY_ESCAPE");
+        return luaEnumString_KeyboardKey_KEY_ESCAPE;
     if (e == Keyboard::KEY_BACKSPACE)
-        return std::string("KEY_BACKSPACE");
+        return luaEnumString_KeyboardKey_KEY_BACKSPACE;
     if (e == Keyboard::KEY_TAB)
-        return std::string("KEY_TAB");
+        return luaEnumString_KeyboardKey_KEY_TAB;
     if (e == Keyboard::KEY_BACK_TAB)
-        return std::string("KEY_BACK_TAB");
+        return luaEnumString_KeyboardKey_KEY_BACK_TAB;
     if (e == Keyboard::KEY_RETURN)
-        return std::string("KEY_RETURN");
+        return luaEnumString_KeyboardKey_KEY_RETURN;
     if (e == Keyboard::KEY_CAPS_LOCK)
-        return std::string("KEY_CAPS_LOCK");
+        return luaEnumString_KeyboardKey_KEY_CAPS_LOCK;
     if (e == Keyboard::KEY_SHIFT)
-        return std::string("KEY_SHIFT");
+        return luaEnumString_KeyboardKey_KEY_SHIFT;
     if (e == Keyboard::KEY_CTRL)
-        return std::string("KEY_CTRL");
+        return luaEnumString_KeyboardKey_KEY_CTRL;
     if (e == Keyboard::KEY_ALT)
-        return std::string("KEY_ALT");
+        return luaEnumString_KeyboardKey_KEY_ALT;
     if (e == Keyboard::KEY_MENU)
-        return std::string("KEY_MENU");
+        return luaEnumString_KeyboardKey_KEY_MENU;
     if (e == Keyboard::KEY_HYPER)
-        return std::string("KEY_HYPER");
+        return luaEnumString_KeyboardKey_KEY_HYPER;
     if (e == Keyboard::KEY_INSERT)
-        return std::string("KEY_INSERT");
+        return luaEnumString_KeyboardKey_KEY_INSERT;
     if (e == Keyboard::KEY_HOME)
-        return std::string("KEY_HOME");
+        return luaEnumString_KeyboardKey_KEY_HOME;
     if (e == Keyboard::KEY_PG_UP)
-        return std::string("KEY_PG_UP");
+        return luaEnumString_KeyboardKey_KEY_PG_UP;
     if (e == Keyboard::KEY_DELETE)
-        return std::string("KEY_DELETE");
+        return luaEnumString_KeyboardKey_KEY_DELETE;
     if (e == Keyboard::KEY_END)
-        return std::string("KEY_END");
+        return luaEnumString_KeyboardKey_KEY_END;
     if (e == Keyboard::KEY_PG_DOWN)
-        return std::string("KEY_PG_DOWN");
+        return luaEnumString_KeyboardKey_KEY_PG_DOWN;
     if (e == Keyboard::KEY_LEFT_ARROW)
-        return std::string("KEY_LEFT_ARROW");
+        return luaEnumString_KeyboardKey_KEY_LEFT_ARROW;
     if (e == Keyboard::KEY_RIGHT_ARROW)
-        return std::string("KEY_RIGHT_ARROW");
+        return luaEnumString_KeyboardKey_KEY_RIGHT_ARROW;
     if (e == Keyboard::KEY_UP_ARROW)
-        return std::string("KEY_UP_ARROW");
+        return luaEnumString_KeyboardKey_KEY_UP_ARROW;
     if (e == Keyboard::KEY_DOWN_ARROW)
-        return std::string("KEY_DOWN_ARROW");
+        return luaEnumString_KeyboardKey_KEY_DOWN_ARROW;
     if (e == Keyboard::KEY_NUM_LOCK)
-        return std::string("KEY_NUM_LOCK");
+        return luaEnumString_KeyboardKey_KEY_NUM_LOCK;
     if (e == Keyboard::KEY_KP_PLUS)
-        return std::string("KEY_KP_PLUS");
+        return luaEnumString_KeyboardKey_KEY_KP_PLUS;
     if (e == Keyboard::KEY_KP_MINUS)
-        return std::string("KEY_KP_MINUS");
+        return luaEnumString_KeyboardKey_KEY_KP_MINUS;
     if (e == Keyboard::KEY_KP_MULTIPLY)
-        return std::string("KEY_KP_MULTIPLY");
+        return luaEnumString_KeyboardKey_KEY_KP_MULTIPLY;
     if (e == Keyboard::KEY_KP_DIVIDE)
-        return std::string("KEY_KP_DIVIDE");
+        return luaEnumString_KeyboardKey_KEY_KP_DIVIDE;
     if (e == Keyboard::KEY_KP_ENTER)
-        return std::string("KEY_KP_ENTER");
+        return luaEnumString_KeyboardKey_KEY_KP_ENTER;
     if (e == Keyboard::KEY_KP_HOME)
-        return std::string("KEY_KP_HOME");
+        return luaEnumString_KeyboardKey_KEY_KP_HOME;
     if (e == Keyboard::KEY_KP_UP)
-        return std::string("KEY_KP_UP");
+        return luaEnumString_KeyboardKey_KEY_KP_UP;
     if (e == Keyboard::KEY_KP_PG_UP)
-        return std::string("KEY_KP_PG_UP");
+        return luaEnumString_KeyboardKey_KEY_KP_PG_UP;
     if (e == Keyboard::KEY_KP_LEFT)
-        return std::string("KEY_KP_LEFT");
+        return luaEnumString_KeyboardKey_KEY_KP_LEFT;
     if (e == Keyboard::KEY_KP_FIVE)
-        return std::string("KEY_KP_FIVE");
+        return luaEnumString_KeyboardKey_KEY_KP_FIVE;
     if (e == Keyboard::KEY_KP_RIGHT)
-        return std::string("KEY_KP_RIGHT");
+        return luaEnumString_KeyboardKey_KEY_KP_RIGHT;
     if (e == Keyboard::KEY_KP_END)
-        return std::string("KEY_KP_END");
+        return luaEnumString_KeyboardKey_KEY_KP_END;
     if (e == Keyboard::KEY_KP_DOWN)
-        return std::string("KEY_KP_DOWN");
+        return luaEnumString_KeyboardKey_KEY_KP_DOWN;
     if (e == Keyboard::KEY_KP_PG_DOWN)
-        return std::string("KEY_KP_PG_DOWN");
+        return luaEnumString_KeyboardKey_KEY_KP_PG_DOWN;
     if (e == Keyboard::KEY_KP_INSERT)
-        return std::string("KEY_KP_INSERT");
+        return luaEnumString_KeyboardKey_KEY_KP_INSERT;
     if (e == Keyboard::KEY_KP_DELETE)
-        return std::string("KEY_KP_DELETE");
+        return luaEnumString_KeyboardKey_KEY_KP_DELETE;
     if (e == Keyboard::KEY_F1)
-        return std::string("KEY_F1");
+        return luaEnumString_KeyboardKey_KEY_F1;
     if (e == Keyboard::KEY_F2)
-        return std::string("KEY_F2");
+        return luaEnumString_KeyboardKey_KEY_F2;
     if (e == Keyboard::KEY_F3)
-        return std::string("KEY_F3");
+        return luaEnumString_KeyboardKey_KEY_F3;
     if (e == Keyboard::KEY_F4)
-        return std::string("KEY_F4");
+        return luaEnumString_KeyboardKey_KEY_F4;
     if (e == Keyboard::KEY_F5)
-        return std::string("KEY_F5");
+        return luaEnumString_KeyboardKey_KEY_F5;
     if (e == Keyboard::KEY_F6)
-        return std::string("KEY_F6");
+        return luaEnumString_KeyboardKey_KEY_F6;
     if (e == Keyboard::KEY_F7)
-        return std::string("KEY_F7");
+        return luaEnumString_KeyboardKey_KEY_F7;
     if (e == Keyboard::KEY_F8)
-        return std::string("KEY_F8");
+        return luaEnumString_KeyboardKey_KEY_F8;
     if (e == Keyboard::KEY_F9)
-        return std::string("KEY_F9");
+        return luaEnumString_KeyboardKey_KEY_F9;
     if (e == Keyboard::KEY_F10)
-        return std::string("KEY_F10");
+        return luaEnumString_KeyboardKey_KEY_F10;
     if (e == Keyboard::KEY_F11)
-        return std::string("KEY_F11");
+        return luaEnumString_KeyboardKey_KEY_F11;
     if (e == Keyboard::KEY_F12)
-        return std::string("KEY_F12");
+        return luaEnumString_KeyboardKey_KEY_F12;
     if (e == Keyboard::KEY_SPACE)
-        return std::string("KEY_SPACE");
+        return luaEnumString_KeyboardKey_KEY_SPACE;
     if (e == Keyboard::KEY_EXCLAM)
-        return std::string("KEY_EXCLAM");
+        return luaEnumString_KeyboardKey_KEY_EXCLAM;
     if (e == Keyboard::KEY_QUOTE)
-        return std::string("KEY_QUOTE");
+        return luaEnumString_KeyboardKey_KEY_QUOTE;
     if (e == Keyboard::KEY_NUMBER)
-        return std::string("KEY_NUMBER");
+        return luaEnumString_KeyboardKey_KEY_NUMBER;
     if (e == Keyboard::KEY_DOLLAR)
-        return std::string("KEY_DOLLAR");
+        return luaEnumString_KeyboardKey_KEY_DOLLAR;
     if (e == Keyboard::KEY_PERCENT)
-        return std::string("KEY_PERCENT");
+        return luaEnumString_KeyboardKey_KEY_PERCENT;
     if (e == Keyboard::KEY_CIRCUMFLEX)
-        return std::string("KEY_CIRCUMFLEX");
+        return luaEnumString_KeyboardKey_KEY_CIRCUMFLEX;
     if (e == Keyboard::KEY_AMPERSAND)
-        return std::string("KEY_AMPERSAND");
+        return luaEnumString_KeyboardKey_KEY_AMPERSAND;
     if (e == Keyboard::KEY_APOSTROPHE)
-        return std::string("KEY_APOSTROPHE");
+        return luaEnumString_KeyboardKey_KEY_APOSTROPHE;
     if (e == Keyboard::KEY_LEFT_PARENTHESIS)
-        return std::string("KEY_LEFT_PARENTHESIS");
+        return luaEnumString_KeyboardKey_KEY_LEFT_PARENTHESIS;
     if (e == Keyboard::KEY_RIGHT_PARENTHESIS)
-        return std::string("KEY_RIGHT_PARENTHESIS");
+        return luaEnumString_KeyboardKey_KEY_RIGHT_PARENTHESIS;
     if (e == Keyboard::KEY_ASTERISK)
-        return std::string("KEY_ASTERISK");
+        return luaEnumString_KeyboardKey_KEY_ASTERISK;
     if (e == Keyboard::KEY_PLUS)
-        return std::string("KEY_PLUS");
+        return luaEnumString_KeyboardKey_KEY_PLUS;
     if (e == Keyboard::KEY_COMMA)
-        return std::string("KEY_COMMA");
+        return luaEnumString_KeyboardKey_KEY_COMMA;
     if (e == Keyboard::KEY_MINUS)
-        return std::string("KEY_MINUS");
+        return luaEnumString_KeyboardKey_KEY_MINUS;
     if (e == Keyboard::KEY_PERIOD)
-        return std::string("KEY_PERIOD");
+        return luaEnumString_KeyboardKey_KEY_PERIOD;
     if (e == Keyboard::KEY_SLASH)
-        return std::string("KEY_SLASH");
+        return luaEnumString_KeyboardKey_KEY_SLASH;
     if (e == Keyboard::KEY_ZERO)
-        return std::string("KEY_ZERO");
+        return luaEnumString_KeyboardKey_KEY_ZERO;
     if (e == Keyboard::KEY_ONE)
-        return std::string("KEY_ONE");
+        return luaEnumString_KeyboardKey_KEY_ONE;
     if (e == Keyboard::KEY_TWO)
-        return std::string("KEY_TWO");
+        return luaEnumString_KeyboardKey_KEY_TWO;
     if (e == Keyboard::KEY_THREE)
-        return std::string("KEY_THREE");
+        return luaEnumString_KeyboardKey_KEY_THREE;
     if (e == Keyboard::KEY_FOUR)
-        return std::string("KEY_FOUR");
+        return luaEnumString_KeyboardKey_KEY_FOUR;
     if (e == Keyboard::KEY_FIVE)
-        return std::string("KEY_FIVE");
+        return luaEnumString_KeyboardKey_KEY_FIVE;
     if (e == Keyboard::KEY_SIX)
-        return std::string("KEY_SIX");
+        return luaEnumString_KeyboardKey_KEY_SIX;
     if (e == Keyboard::KEY_SEVEN)
-        return std::string("KEY_SEVEN");
+        return luaEnumString_KeyboardKey_KEY_SEVEN;
     if (e == Keyboard::KEY_EIGHT)
-        return std::string("KEY_EIGHT");
+        return luaEnumString_KeyboardKey_KEY_EIGHT;
     if (e == Keyboard::KEY_NINE)
-        return std::string("KEY_NINE");
+        return luaEnumString_KeyboardKey_KEY_NINE;
     if (e == Keyboard::KEY_COLON)
-        return std::string("KEY_COLON");
+        return luaEnumString_KeyboardKey_KEY_COLON;
     if (e == Keyboard::KEY_SEMICOLON)
-        return std::string("KEY_SEMICOLON");
+        return luaEnumString_KeyboardKey_KEY_SEMICOLON;
     if (e == Keyboard::KEY_LESS_THAN)
-        return std::string("KEY_LESS_THAN");
+        return luaEnumString_KeyboardKey_KEY_LESS_THAN;
     if (e == Keyboard::KEY_EQUAL)
-        return std::string("KEY_EQUAL");
+        return luaEnumString_KeyboardKey_KEY_EQUAL;
     if (e == Keyboard::KEY_GREATER_THAN)
-        return std::string("KEY_GREATER_THAN");
+        return luaEnumString_KeyboardKey_KEY_GREATER_THAN;
     if (e == Keyboard::KEY_QUESTION)
-        return std::string("KEY_QUESTION");
+        return luaEnumString_KeyboardKey_KEY_QUESTION;
     if (e == Keyboard::KEY_AT)
-        return std::string("KEY_AT");
+        return luaEnumString_KeyboardKey_KEY_AT;
     if (e == Keyboard::KEY_CAPITAL_A)
-        return std::string("KEY_CAPITAL_A");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_A;
     if (e == Keyboard::KEY_CAPITAL_B)
-        return std::string("KEY_CAPITAL_B");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_B;
     if (e == Keyboard::KEY_CAPITAL_C)
-        return std::string("KEY_CAPITAL_C");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_C;
     if (e == Keyboard::KEY_CAPITAL_D)
-        return std::string("KEY_CAPITAL_D");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_D;
     if (e == Keyboard::KEY_CAPITAL_E)
-        return std::string("KEY_CAPITAL_E");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_E;
     if (e == Keyboard::KEY_CAPITAL_F)
-        return std::string("KEY_CAPITAL_F");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_F;
     if (e == Keyboard::KEY_CAPITAL_G)
-        return std::string("KEY_CAPITAL_G");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_G;
     if (e == Keyboard::KEY_CAPITAL_H)
-        return std::string("KEY_CAPITAL_H");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_H;
     if (e == Keyboard::KEY_CAPITAL_I)
-        return std::string("KEY_CAPITAL_I");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_I;
     if (e == Keyboard::KEY_CAPITAL_J)
-        return std::string("KEY_CAPITAL_J");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_J;
     if (e == Keyboard::KEY_CAPITAL_K)
-        return std::string("KEY_CAPITAL_K");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_K;
     if (e == Keyboard::KEY_CAPITAL_L)
-        return std::string("KEY_CAPITAL_L");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_L;
     if (e == Keyboard::KEY_CAPITAL_M)
-        return std::string("KEY_CAPITAL_M");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_M;
     if (e == Keyboard::KEY_CAPITAL_N)
-        return std::string("KEY_CAPITAL_N");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_N;
     if (e == Keyboard::KEY_CAPITAL_O)
-        return std::string("KEY_CAPITAL_O");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_O;
     if (e == Keyboard::KEY_CAPITAL_P)
-        return std::string("KEY_CAPITAL_P");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_P;
     if (e == Keyboard::KEY_CAPITAL_Q)
-        return std::string("KEY_CAPITAL_Q");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_Q;
     if (e == Keyboard::KEY_CAPITAL_R)
-        return std::string("KEY_CAPITAL_R");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_R;
     if (e == Keyboard::KEY_CAPITAL_S)
-        return std::string("KEY_CAPITAL_S");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_S;
     if (e == Keyboard::KEY_CAPITAL_T)
-        return std::string("KEY_CAPITAL_T");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_T;
     if (e == Keyboard::KEY_CAPITAL_U)
-        return std::string("KEY_CAPITAL_U");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_U;
     if (e == Keyboard::KEY_CAPITAL_V)
-        return std::string("KEY_CAPITAL_V");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_V;
     if (e == Keyboard::KEY_CAPITAL_W)
-        return std::string("KEY_CAPITAL_W");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_W;
     if (e == Keyboard::KEY_CAPITAL_X)
-        return std::string("KEY_CAPITAL_X");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_X;
     if (e == Keyboard::KEY_CAPITAL_Y)
-        return std::string("KEY_CAPITAL_Y");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_Y;
     if (e == Keyboard::KEY_CAPITAL_Z)
-        return std::string("KEY_CAPITAL_Z");
+        return luaEnumString_KeyboardKey_KEY_CAPITAL_Z;
     if (e == Keyboard::KEY_LEFT_BRACKET)
-        return std::string("KEY_LEFT_BRACKET");
+        return luaEnumString_KeyboardKey_KEY_LEFT_BRACKET;
     if (e == Keyboard::KEY_BACK_SLASH)
-        return std::string("KEY_BACK_SLASH");
+        return luaEnumString_KeyboardKey_KEY_BACK_SLASH;
     if (e == Keyboard::KEY_RIGHT_BRACKET)
-        return std::string("KEY_RIGHT_BRACKET");
+        return luaEnumString_KeyboardKey_KEY_RIGHT_BRACKET;
     if (e == Keyboard::KEY_UNDERSCORE)
-        return std::string("KEY_UNDERSCORE");
+        return luaEnumString_KeyboardKey_KEY_UNDERSCORE;
     if (e == Keyboard::KEY_GRAVE)
-        return std::string("KEY_GRAVE");
+        return luaEnumString_KeyboardKey_KEY_GRAVE;
     if (e == Keyboard::KEY_A)
-        return std::string("KEY_A");
+        return luaEnumString_KeyboardKey_KEY_A;
     if (e == Keyboard::KEY_B)
-        return std::string("KEY_B");
+        return luaEnumString_KeyboardKey_KEY_B;
     if (e == Keyboard::KEY_C)
-        return std::string("KEY_C");
+        return luaEnumString_KeyboardKey_KEY_C;
     if (e == Keyboard::KEY_D)
-        return std::string("KEY_D");
+        return luaEnumString_KeyboardKey_KEY_D;
     if (e == Keyboard::KEY_E)
-        return std::string("KEY_E");
+        return luaEnumString_KeyboardKey_KEY_E;
     if (e == Keyboard::KEY_F)
-        return std::string("KEY_F");
+        return luaEnumString_KeyboardKey_KEY_F;
     if (e == Keyboard::KEY_G)
-        return std::string("KEY_G");
+        return luaEnumString_KeyboardKey_KEY_G;
     if (e == Keyboard::KEY_H)
-        return std::string("KEY_H");
+        return luaEnumString_KeyboardKey_KEY_H;
     if (e == Keyboard::KEY_I)
-        return std::string("KEY_I");
+        return luaEnumString_KeyboardKey_KEY_I;
     if (e == Keyboard::KEY_J)
-        return std::string("KEY_J");
+        return luaEnumString_KeyboardKey_KEY_J;
     if (e == Keyboard::KEY_K)
-        return std::string("KEY_K");
+        return luaEnumString_KeyboardKey_KEY_K;
     if (e == Keyboard::KEY_L)
-        return std::string("KEY_L");
+        return luaEnumString_KeyboardKey_KEY_L;
     if (e == Keyboard::KEY_M)
-        return std::string("KEY_M");
+        return luaEnumString_KeyboardKey_KEY_M;
     if (e == Keyboard::KEY_N)
-        return std::string("KEY_N");
+        return luaEnumString_KeyboardKey_KEY_N;
     if (e == Keyboard::KEY_O)
-        return std::string("KEY_O");
+        return luaEnumString_KeyboardKey_KEY_O;
     if (e == Keyboard::KEY_P)
-        return std::string("KEY_P");
+        return luaEnumString_KeyboardKey_KEY_P;
     if (e == Keyboard::KEY_Q)
-        return std::string("KEY_Q");
+        return luaEnumString_KeyboardKey_KEY_Q;
     if (e == Keyboard::KEY_R)
-        return std::string("KEY_R");
+        return luaEnumString_KeyboardKey_KEY_R;
     if (e == Keyboard::KEY_S)
-        return std::string("KEY_S");
+        return luaEnumString_KeyboardKey_KEY_S;
     if (e == Keyboard::KEY_T)
-        return std::string("KEY_T");
+        return luaEnumString_KeyboardKey_KEY_T;
     if (e == Keyboard::KEY_U)
-        return std::string("KEY_U");
+        return luaEnumString_KeyboardKey_KEY_U;
     if (e == Keyboard::KEY_V)
-        return std::string("KEY_V");
+        return luaEnumString_KeyboardKey_KEY_V;
     if (e == Keyboard::KEY_W)
-        return std::string("KEY_W");
+        return luaEnumString_KeyboardKey_KEY_W;
     if (e == Keyboard::KEY_X)
-        return std::string("KEY_X");
+        return luaEnumString_KeyboardKey_KEY_X;
     if (e == Keyboard::KEY_Y)
-        return std::string("KEY_Y");
+        return luaEnumString_KeyboardKey_KEY_Y;
     if (e == Keyboard::KEY_Z)
-        return std::string("KEY_Z");
+        return luaEnumString_KeyboardKey_KEY_Z;
     if (e == Keyboard::KEY_LEFT_BRACE)
-        return std::string("KEY_LEFT_BRACE");
+        return luaEnumString_KeyboardKey_KEY_LEFT_BRACE;
     if (e == Keyboard::KEY_BAR)
-        return std::string("KEY_BAR");
+        return luaEnumString_KeyboardKey_KEY_BAR;
     if (e == Keyboard::KEY_RIGHT_BRACE)
-        return std::string("KEY_RIGHT_BRACE");
+        return luaEnumString_KeyboardKey_KEY_RIGHT_BRACE;
     if (e == Keyboard::KEY_TILDE)
-        return std::string("KEY_TILDE");
+        return luaEnumString_KeyboardKey_KEY_TILDE;
     if (e == Keyboard::KEY_EURO)
-        return std::string("KEY_EURO");
+        return luaEnumString_KeyboardKey_KEY_EURO;
     if (e == Keyboard::KEY_POUND)
-        return std::string("KEY_POUND");
+        return luaEnumString_KeyboardKey_KEY_POUND;
     if (e == Keyboard::KEY_YEN)
-        return std::string("KEY_YEN");
+        return luaEnumString_KeyboardKey_KEY_YEN;
     if (e == Keyboard::KEY_MIDDLE_DOT)
-        return std::string("KEY_MIDDLE_DOT");
+        return luaEnumString_KeyboardKey_KEY_MIDDLE_DOT;
     if (e == Keyboard::KEY_SEARCH)
-        return std::string("KEY_SEARCH");
+        return luaEnumString_KeyboardKey_KEY_SEARCH;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Keyboard::Key.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_KeyboardKeyEvent_KEY_PRESS = "KEY_PRESS";
+static const char* luaEnumString_KeyboardKeyEvent_KEY_RELEASE = "KEY_RELEASE";
+static const char* luaEnumString_KeyboardKeyEvent_KEY_CHAR = "KEY_CHAR";
+
 Keyboard::KeyEvent lua_enumFromString_KeyboardKeyEvent(const char* s)
 {
-    if (strcmp(s, "KEY_PRESS") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKeyEvent_KEY_PRESS) == 0)
         return Keyboard::KEY_PRESS;
-    if (strcmp(s, "KEY_RELEASE") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKeyEvent_KEY_RELEASE) == 0)
         return Keyboard::KEY_RELEASE;
-    if (strcmp(s, "KEY_CHAR") == 0)
+    if (strcmp(s, luaEnumString_KeyboardKeyEvent_KEY_CHAR) == 0)
         return Keyboard::KEY_CHAR;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Keyboard::KeyEvent.", s);
     return Keyboard::KEY_PRESS;
 }
 
-std::string lua_stringFromEnum_KeyboardKeyEvent(Keyboard::KeyEvent e)
+const char* lua_stringFromEnum_KeyboardKeyEvent(Keyboard::KeyEvent e)
 {
     if (e == Keyboard::KEY_PRESS)
-        return std::string("KEY_PRESS");
+        return luaEnumString_KeyboardKeyEvent_KEY_PRESS;
     if (e == Keyboard::KEY_RELEASE)
-        return std::string("KEY_RELEASE");
+        return luaEnumString_KeyboardKeyEvent_KEY_RELEASE;
     if (e == Keyboard::KEY_CHAR)
-        return std::string("KEY_CHAR");
+        return luaEnumString_KeyboardKeyEvent_KEY_CHAR;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Keyboard::KeyEvent.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_LayoutType_LAYOUT_FLOW = "LAYOUT_FLOW";
+static const char* luaEnumString_LayoutType_LAYOUT_VERTICAL = "LAYOUT_VERTICAL";
+static const char* luaEnumString_LayoutType_LAYOUT_ABSOLUTE = "LAYOUT_ABSOLUTE";
+static const char* luaEnumString_LayoutType_LAYOUT_SCROLL = "LAYOUT_SCROLL";
+
 Layout::Type lua_enumFromString_LayoutType(const char* s)
 {
-    if (strcmp(s, "LAYOUT_FLOW") == 0)
+    if (strcmp(s, luaEnumString_LayoutType_LAYOUT_FLOW) == 0)
         return Layout::LAYOUT_FLOW;
-    if (strcmp(s, "LAYOUT_VERTICAL") == 0)
+    if (strcmp(s, luaEnumString_LayoutType_LAYOUT_VERTICAL) == 0)
         return Layout::LAYOUT_VERTICAL;
-    if (strcmp(s, "LAYOUT_ABSOLUTE") == 0)
+    if (strcmp(s, luaEnumString_LayoutType_LAYOUT_ABSOLUTE) == 0)
         return Layout::LAYOUT_ABSOLUTE;
-    if (strcmp(s, "LAYOUT_SCROLL") == 0)
+    if (strcmp(s, luaEnumString_LayoutType_LAYOUT_SCROLL) == 0)
         return Layout::LAYOUT_SCROLL;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Layout::Type.", s);
     return Layout::LAYOUT_FLOW;
 }
 
-std::string lua_stringFromEnum_LayoutType(Layout::Type e)
+const char* lua_stringFromEnum_LayoutType(Layout::Type e)
 {
     if (e == Layout::LAYOUT_FLOW)
-        return std::string("LAYOUT_FLOW");
+        return luaEnumString_LayoutType_LAYOUT_FLOW;
     if (e == Layout::LAYOUT_VERTICAL)
-        return std::string("LAYOUT_VERTICAL");
+        return luaEnumString_LayoutType_LAYOUT_VERTICAL;
     if (e == Layout::LAYOUT_ABSOLUTE)
-        return std::string("LAYOUT_ABSOLUTE");
+        return luaEnumString_LayoutType_LAYOUT_ABSOLUTE;
     if (e == Layout::LAYOUT_SCROLL)
-        return std::string("LAYOUT_SCROLL");
+        return luaEnumString_LayoutType_LAYOUT_SCROLL;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Layout::Type.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_LightType_DIRECTIONAL = "DIRECTIONAL";
+static const char* luaEnumString_LightType_POINT = "POINT";
+static const char* luaEnumString_LightType_SPOT = "SPOT";
+
 Light::Type lua_enumFromString_LightType(const char* s)
 {
-    if (strcmp(s, "DIRECTIONAL") == 0)
+    if (strcmp(s, luaEnumString_LightType_DIRECTIONAL) == 0)
         return Light::DIRECTIONAL;
-    if (strcmp(s, "POINT") == 0)
+    if (strcmp(s, luaEnumString_LightType_POINT) == 0)
         return Light::POINT;
-    if (strcmp(s, "SPOT") == 0)
+    if (strcmp(s, luaEnumString_LightType_SPOT) == 0)
         return Light::SPOT;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Light::Type.", s);
     return Light::DIRECTIONAL;
 }
 
-std::string lua_stringFromEnum_LightType(Light::Type e)
+const char* lua_stringFromEnum_LightType(Light::Type e)
 {
     if (e == Light::DIRECTIONAL)
-        return std::string("DIRECTIONAL");
+        return luaEnumString_LightType_DIRECTIONAL;
     if (e == Light::POINT)
-        return std::string("POINT");
+        return luaEnumString_LightType_POINT;
     if (e == Light::SPOT)
-        return std::string("SPOT");
+        return luaEnumString_LightType_SPOT;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Light::Type.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_MeshIndexFormat_INDEX8 = "INDEX8";
+static const char* luaEnumString_MeshIndexFormat_INDEX16 = "INDEX16";
+static const char* luaEnumString_MeshIndexFormat_INDEX32 = "INDEX32";
+
 Mesh::IndexFormat lua_enumFromString_MeshIndexFormat(const char* s)
 {
-    if (strcmp(s, "INDEX8") == 0)
+    if (strcmp(s, luaEnumString_MeshIndexFormat_INDEX8) == 0)
         return Mesh::INDEX8;
-    if (strcmp(s, "INDEX16") == 0)
+    if (strcmp(s, luaEnumString_MeshIndexFormat_INDEX16) == 0)
         return Mesh::INDEX16;
-    if (strcmp(s, "INDEX32") == 0)
+    if (strcmp(s, luaEnumString_MeshIndexFormat_INDEX32) == 0)
         return Mesh::INDEX32;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Mesh::IndexFormat.", s);
     return Mesh::INDEX8;
 }
 
-std::string lua_stringFromEnum_MeshIndexFormat(Mesh::IndexFormat e)
+const char* lua_stringFromEnum_MeshIndexFormat(Mesh::IndexFormat e)
 {
     if (e == Mesh::INDEX8)
-        return std::string("INDEX8");
+        return luaEnumString_MeshIndexFormat_INDEX8;
     if (e == Mesh::INDEX16)
-        return std::string("INDEX16");
+        return luaEnumString_MeshIndexFormat_INDEX16;
     if (e == Mesh::INDEX32)
-        return std::string("INDEX32");
+        return luaEnumString_MeshIndexFormat_INDEX32;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Mesh::IndexFormat.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_MeshPrimitiveType_TRIANGLES = "TRIANGLES";
+static const char* luaEnumString_MeshPrimitiveType_TRIANGLE_STRIP = "TRIANGLE_STRIP";
+static const char* luaEnumString_MeshPrimitiveType_LINES = "LINES";
+static const char* luaEnumString_MeshPrimitiveType_LINE_STRIP = "LINE_STRIP";
+static const char* luaEnumString_MeshPrimitiveType_POINTS = "POINTS";
+
 Mesh::PrimitiveType lua_enumFromString_MeshPrimitiveType(const char* s)
 {
-    if (strcmp(s, "TRIANGLES") == 0)
+    if (strcmp(s, luaEnumString_MeshPrimitiveType_TRIANGLES) == 0)
         return Mesh::TRIANGLES;
-    if (strcmp(s, "TRIANGLE_STRIP") == 0)
+    if (strcmp(s, luaEnumString_MeshPrimitiveType_TRIANGLE_STRIP) == 0)
         return Mesh::TRIANGLE_STRIP;
-    if (strcmp(s, "LINES") == 0)
+    if (strcmp(s, luaEnumString_MeshPrimitiveType_LINES) == 0)
         return Mesh::LINES;
-    if (strcmp(s, "LINE_STRIP") == 0)
+    if (strcmp(s, luaEnumString_MeshPrimitiveType_LINE_STRIP) == 0)
         return Mesh::LINE_STRIP;
-    if (strcmp(s, "POINTS") == 0)
+    if (strcmp(s, luaEnumString_MeshPrimitiveType_POINTS) == 0)
         return Mesh::POINTS;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Mesh::PrimitiveType.", s);
     return Mesh::TRIANGLES;
 }
 
-std::string lua_stringFromEnum_MeshPrimitiveType(Mesh::PrimitiveType e)
+const char* lua_stringFromEnum_MeshPrimitiveType(Mesh::PrimitiveType e)
 {
     if (e == Mesh::TRIANGLES)
-        return std::string("TRIANGLES");
+        return luaEnumString_MeshPrimitiveType_TRIANGLES;
     if (e == Mesh::TRIANGLE_STRIP)
-        return std::string("TRIANGLE_STRIP");
+        return luaEnumString_MeshPrimitiveType_TRIANGLE_STRIP;
     if (e == Mesh::LINES)
-        return std::string("LINES");
+        return luaEnumString_MeshPrimitiveType_LINES;
     if (e == Mesh::LINE_STRIP)
-        return std::string("LINE_STRIP");
+        return luaEnumString_MeshPrimitiveType_LINE_STRIP;
     if (e == Mesh::POINTS)
-        return std::string("POINTS");
+        return luaEnumString_MeshPrimitiveType_POINTS;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Mesh::PrimitiveType.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_MouseMouseEvent_MOUSE_PRESS_LEFT_BUTTON = "MOUSE_PRESS_LEFT_BUTTON";
+static const char* luaEnumString_MouseMouseEvent_MOUSE_RELEASE_LEFT_BUTTON = "MOUSE_RELEASE_LEFT_BUTTON";
+static const char* luaEnumString_MouseMouseEvent_MOUSE_PRESS_MIDDLE_BUTTON = "MOUSE_PRESS_MIDDLE_BUTTON";
+static const char* luaEnumString_MouseMouseEvent_MOUSE_RELEASE_MIDDLE_BUTTON = "MOUSE_RELEASE_MIDDLE_BUTTON";
+static const char* luaEnumString_MouseMouseEvent_MOUSE_PRESS_RIGHT_BUTTON = "MOUSE_PRESS_RIGHT_BUTTON";
+static const char* luaEnumString_MouseMouseEvent_MOUSE_RELEASE_RIGHT_BUTTON = "MOUSE_RELEASE_RIGHT_BUTTON";
+static const char* luaEnumString_MouseMouseEvent_MOUSE_MOVE = "MOUSE_MOVE";
+static const char* luaEnumString_MouseMouseEvent_MOUSE_WHEEL = "MOUSE_WHEEL";
+
 Mouse::MouseEvent lua_enumFromString_MouseMouseEvent(const char* s)
 {
-    if (strcmp(s, "MOUSE_PRESS_LEFT_BUTTON") == 0)
+    if (strcmp(s, luaEnumString_MouseMouseEvent_MOUSE_PRESS_LEFT_BUTTON) == 0)
         return Mouse::MOUSE_PRESS_LEFT_BUTTON;
-    if (strcmp(s, "MOUSE_RELEASE_LEFT_BUTTON") == 0)
+    if (strcmp(s, luaEnumString_MouseMouseEvent_MOUSE_RELEASE_LEFT_BUTTON) == 0)
         return Mouse::MOUSE_RELEASE_LEFT_BUTTON;
-    if (strcmp(s, "MOUSE_PRESS_MIDDLE_BUTTON") == 0)
+    if (strcmp(s, luaEnumString_MouseMouseEvent_MOUSE_PRESS_MIDDLE_BUTTON) == 0)
         return Mouse::MOUSE_PRESS_MIDDLE_BUTTON;
-    if (strcmp(s, "MOUSE_RELEASE_MIDDLE_BUTTON") == 0)
+    if (strcmp(s, luaEnumString_MouseMouseEvent_MOUSE_RELEASE_MIDDLE_BUTTON) == 0)
         return Mouse::MOUSE_RELEASE_MIDDLE_BUTTON;
-    if (strcmp(s, "MOUSE_PRESS_RIGHT_BUTTON") == 0)
+    if (strcmp(s, luaEnumString_MouseMouseEvent_MOUSE_PRESS_RIGHT_BUTTON) == 0)
         return Mouse::MOUSE_PRESS_RIGHT_BUTTON;
-    if (strcmp(s, "MOUSE_RELEASE_RIGHT_BUTTON") == 0)
+    if (strcmp(s, luaEnumString_MouseMouseEvent_MOUSE_RELEASE_RIGHT_BUTTON) == 0)
         return Mouse::MOUSE_RELEASE_RIGHT_BUTTON;
-    if (strcmp(s, "MOUSE_MOVE") == 0)
+    if (strcmp(s, luaEnumString_MouseMouseEvent_MOUSE_MOVE) == 0)
         return Mouse::MOUSE_MOVE;
-    if (strcmp(s, "MOUSE_WHEEL") == 0)
+    if (strcmp(s, luaEnumString_MouseMouseEvent_MOUSE_WHEEL) == 0)
         return Mouse::MOUSE_WHEEL;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Mouse::MouseEvent.", s);
     return Mouse::MOUSE_PRESS_LEFT_BUTTON;
 }
 
-std::string lua_stringFromEnum_MouseMouseEvent(Mouse::MouseEvent e)
+const char* lua_stringFromEnum_MouseMouseEvent(Mouse::MouseEvent e)
 {
     if (e == Mouse::MOUSE_PRESS_LEFT_BUTTON)
-        return std::string("MOUSE_PRESS_LEFT_BUTTON");
+        return luaEnumString_MouseMouseEvent_MOUSE_PRESS_LEFT_BUTTON;
     if (e == Mouse::MOUSE_RELEASE_LEFT_BUTTON)
-        return std::string("MOUSE_RELEASE_LEFT_BUTTON");
+        return luaEnumString_MouseMouseEvent_MOUSE_RELEASE_LEFT_BUTTON;
     if (e == Mouse::MOUSE_PRESS_MIDDLE_BUTTON)
-        return std::string("MOUSE_PRESS_MIDDLE_BUTTON");
+        return luaEnumString_MouseMouseEvent_MOUSE_PRESS_MIDDLE_BUTTON;
     if (e == Mouse::MOUSE_RELEASE_MIDDLE_BUTTON)
-        return std::string("MOUSE_RELEASE_MIDDLE_BUTTON");
+        return luaEnumString_MouseMouseEvent_MOUSE_RELEASE_MIDDLE_BUTTON;
     if (e == Mouse::MOUSE_PRESS_RIGHT_BUTTON)
-        return std::string("MOUSE_PRESS_RIGHT_BUTTON");
+        return luaEnumString_MouseMouseEvent_MOUSE_PRESS_RIGHT_BUTTON;
     if (e == Mouse::MOUSE_RELEASE_RIGHT_BUTTON)
-        return std::string("MOUSE_RELEASE_RIGHT_BUTTON");
+        return luaEnumString_MouseMouseEvent_MOUSE_RELEASE_RIGHT_BUTTON;
     if (e == Mouse::MOUSE_MOVE)
-        return std::string("MOUSE_MOVE");
+        return luaEnumString_MouseMouseEvent_MOUSE_MOVE;
     if (e == Mouse::MOUSE_WHEEL)
-        return std::string("MOUSE_WHEEL");
+        return luaEnumString_MouseMouseEvent_MOUSE_WHEEL;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Mouse::MouseEvent.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_NodeType_NODE = "NODE";
+static const char* luaEnumString_NodeType_JOINT = "JOINT";
+
 Node::Type lua_enumFromString_NodeType(const char* s)
 {
-    if (strcmp(s, "NODE") == 0)
+    if (strcmp(s, luaEnumString_NodeType_NODE) == 0)
         return Node::NODE;
-    if (strcmp(s, "JOINT") == 0)
+    if (strcmp(s, luaEnumString_NodeType_JOINT) == 0)
         return Node::JOINT;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Node::Type.", s);
     return Node::NODE;
 }
 
-std::string lua_stringFromEnum_NodeType(Node::Type e)
+const char* lua_stringFromEnum_NodeType(Node::Type e)
 {
     if (e == Node::NODE)
-        return std::string("NODE");
+        return luaEnumString_NodeType_NODE;
     if (e == Node::JOINT)
-        return std::string("JOINT");
+        return luaEnumString_NodeType_JOINT;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Node::Type.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_ParticleEmitterTextureBlending_BLEND_OPAQUE = "BLEND_OPAQUE";
+static const char* luaEnumString_ParticleEmitterTextureBlending_BLEND_TRANSPARENT = "BLEND_TRANSPARENT";
+static const char* luaEnumString_ParticleEmitterTextureBlending_BLEND_ADDITIVE = "BLEND_ADDITIVE";
+static const char* luaEnumString_ParticleEmitterTextureBlending_BLEND_MULTIPLIED = "BLEND_MULTIPLIED";
+
 ParticleEmitter::TextureBlending lua_enumFromString_ParticleEmitterTextureBlending(const char* s)
 {
-    if (strcmp(s, "BLEND_OPAQUE") == 0)
+    if (strcmp(s, luaEnumString_ParticleEmitterTextureBlending_BLEND_OPAQUE) == 0)
         return ParticleEmitter::BLEND_OPAQUE;
-    if (strcmp(s, "BLEND_TRANSPARENT") == 0)
+    if (strcmp(s, luaEnumString_ParticleEmitterTextureBlending_BLEND_TRANSPARENT) == 0)
         return ParticleEmitter::BLEND_TRANSPARENT;
-    if (strcmp(s, "BLEND_ADDITIVE") == 0)
+    if (strcmp(s, luaEnumString_ParticleEmitterTextureBlending_BLEND_ADDITIVE) == 0)
         return ParticleEmitter::BLEND_ADDITIVE;
-    if (strcmp(s, "BLEND_MULTIPLIED") == 0)
+    if (strcmp(s, luaEnumString_ParticleEmitterTextureBlending_BLEND_MULTIPLIED) == 0)
         return ParticleEmitter::BLEND_MULTIPLIED;
     GP_ERROR("Invalid enumeration value '%s' for enumeration ParticleEmitter::TextureBlending.", s);
     return ParticleEmitter::BLEND_OPAQUE;
 }
 
-std::string lua_stringFromEnum_ParticleEmitterTextureBlending(ParticleEmitter::TextureBlending e)
+const char* lua_stringFromEnum_ParticleEmitterTextureBlending(ParticleEmitter::TextureBlending e)
 {
     if (e == ParticleEmitter::BLEND_OPAQUE)
-        return std::string("BLEND_OPAQUE");
+        return luaEnumString_ParticleEmitterTextureBlending_BLEND_OPAQUE;
     if (e == ParticleEmitter::BLEND_TRANSPARENT)
-        return std::string("BLEND_TRANSPARENT");
+        return luaEnumString_ParticleEmitterTextureBlending_BLEND_TRANSPARENT;
     if (e == ParticleEmitter::BLEND_ADDITIVE)
-        return std::string("BLEND_ADDITIVE");
+        return luaEnumString_ParticleEmitterTextureBlending_BLEND_ADDITIVE;
     if (e == ParticleEmitter::BLEND_MULTIPLIED)
-        return std::string("BLEND_MULTIPLIED");
+        return luaEnumString_ParticleEmitterTextureBlending_BLEND_MULTIPLIED;
     GP_ERROR("Invalid enumeration value '%d' for enumeration ParticleEmitter::TextureBlending.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_PhysicsCollisionObjectCollisionListenerEventType_COLLIDING = "COLLIDING";
+static const char* luaEnumString_PhysicsCollisionObjectCollisionListenerEventType_NOT_COLLIDING = "NOT_COLLIDING";
+
 PhysicsCollisionObject::CollisionListener::EventType lua_enumFromString_PhysicsCollisionObjectCollisionListenerEventType(const char* s)
 {
-    if (strcmp(s, "COLLIDING") == 0)
+    if (strcmp(s, luaEnumString_PhysicsCollisionObjectCollisionListenerEventType_COLLIDING) == 0)
         return PhysicsCollisionObject::CollisionListener::COLLIDING;
-    if (strcmp(s, "NOT_COLLIDING") == 0)
+    if (strcmp(s, luaEnumString_PhysicsCollisionObjectCollisionListenerEventType_NOT_COLLIDING) == 0)
         return PhysicsCollisionObject::CollisionListener::NOT_COLLIDING;
     GP_ERROR("Invalid enumeration value '%s' for enumeration PhysicsCollisionObject::CollisionListener::EventType.", s);
     return PhysicsCollisionObject::CollisionListener::COLLIDING;
 }
 
-std::string lua_stringFromEnum_PhysicsCollisionObjectCollisionListenerEventType(PhysicsCollisionObject::CollisionListener::EventType e)
+const char* lua_stringFromEnum_PhysicsCollisionObjectCollisionListenerEventType(PhysicsCollisionObject::CollisionListener::EventType e)
 {
     if (e == PhysicsCollisionObject::CollisionListener::COLLIDING)
-        return std::string("COLLIDING");
+        return luaEnumString_PhysicsCollisionObjectCollisionListenerEventType_COLLIDING;
     if (e == PhysicsCollisionObject::CollisionListener::NOT_COLLIDING)
-        return std::string("NOT_COLLIDING");
+        return luaEnumString_PhysicsCollisionObjectCollisionListenerEventType_NOT_COLLIDING;
     GP_ERROR("Invalid enumeration value '%d' for enumeration PhysicsCollisionObject::CollisionListener::EventType.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_PhysicsCollisionObjectType_RIGID_BODY = "RIGID_BODY";
+static const char* luaEnumString_PhysicsCollisionObjectType_CHARACTER = "CHARACTER";
+static const char* luaEnumString_PhysicsCollisionObjectType_GHOST_OBJECT = "GHOST_OBJECT";
+static const char* luaEnumString_PhysicsCollisionObjectType_NONE = "NONE";
+
 PhysicsCollisionObject::Type lua_enumFromString_PhysicsCollisionObjectType(const char* s)
 {
-    if (strcmp(s, "RIGID_BODY") == 0)
+    if (strcmp(s, luaEnumString_PhysicsCollisionObjectType_RIGID_BODY) == 0)
         return PhysicsCollisionObject::RIGID_BODY;
-    if (strcmp(s, "CHARACTER") == 0)
+    if (strcmp(s, luaEnumString_PhysicsCollisionObjectType_CHARACTER) == 0)
         return PhysicsCollisionObject::CHARACTER;
-    if (strcmp(s, "GHOST_OBJECT") == 0)
+    if (strcmp(s, luaEnumString_PhysicsCollisionObjectType_GHOST_OBJECT) == 0)
         return PhysicsCollisionObject::GHOST_OBJECT;
-    if (strcmp(s, "NONE") == 0)
+    if (strcmp(s, luaEnumString_PhysicsCollisionObjectType_NONE) == 0)
         return PhysicsCollisionObject::NONE;
     GP_ERROR("Invalid enumeration value '%s' for enumeration PhysicsCollisionObject::Type.", s);
     return PhysicsCollisionObject::RIGID_BODY;
 }
 
-std::string lua_stringFromEnum_PhysicsCollisionObjectType(PhysicsCollisionObject::Type e)
+const char* lua_stringFromEnum_PhysicsCollisionObjectType(PhysicsCollisionObject::Type e)
 {
     if (e == PhysicsCollisionObject::RIGID_BODY)
-        return std::string("RIGID_BODY");
+        return luaEnumString_PhysicsCollisionObjectType_RIGID_BODY;
     if (e == PhysicsCollisionObject::CHARACTER)
-        return std::string("CHARACTER");
+        return luaEnumString_PhysicsCollisionObjectType_CHARACTER;
     if (e == PhysicsCollisionObject::GHOST_OBJECT)
-        return std::string("GHOST_OBJECT");
+        return luaEnumString_PhysicsCollisionObjectType_GHOST_OBJECT;
     if (e == PhysicsCollisionObject::NONE)
-        return std::string("NONE");
+        return luaEnumString_PhysicsCollisionObjectType_NONE;
     GP_ERROR("Invalid enumeration value '%d' for enumeration PhysicsCollisionObject::Type.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_PhysicsCollisionShapeType_SHAPE_BOX = "SHAPE_BOX";
+static const char* luaEnumString_PhysicsCollisionShapeType_SHAPE_SPHERE = "SHAPE_SPHERE";
+static const char* luaEnumString_PhysicsCollisionShapeType_SHAPE_CAPSULE = "SHAPE_CAPSULE";
+static const char* luaEnumString_PhysicsCollisionShapeType_SHAPE_MESH = "SHAPE_MESH";
+static const char* luaEnumString_PhysicsCollisionShapeType_SHAPE_HEIGHTFIELD = "SHAPE_HEIGHTFIELD";
+
 PhysicsCollisionShape::Type lua_enumFromString_PhysicsCollisionShapeType(const char* s)
 {
-    if (strcmp(s, "SHAPE_BOX") == 0)
+    if (strcmp(s, luaEnumString_PhysicsCollisionShapeType_SHAPE_BOX) == 0)
         return PhysicsCollisionShape::SHAPE_BOX;
-    if (strcmp(s, "SHAPE_SPHERE") == 0)
+    if (strcmp(s, luaEnumString_PhysicsCollisionShapeType_SHAPE_SPHERE) == 0)
         return PhysicsCollisionShape::SHAPE_SPHERE;
-    if (strcmp(s, "SHAPE_CAPSULE") == 0)
+    if (strcmp(s, luaEnumString_PhysicsCollisionShapeType_SHAPE_CAPSULE) == 0)
         return PhysicsCollisionShape::SHAPE_CAPSULE;
-    if (strcmp(s, "SHAPE_MESH") == 0)
+    if (strcmp(s, luaEnumString_PhysicsCollisionShapeType_SHAPE_MESH) == 0)
         return PhysicsCollisionShape::SHAPE_MESH;
-    if (strcmp(s, "SHAPE_HEIGHTFIELD") == 0)
+    if (strcmp(s, luaEnumString_PhysicsCollisionShapeType_SHAPE_HEIGHTFIELD) == 0)
         return PhysicsCollisionShape::SHAPE_HEIGHTFIELD;
     GP_ERROR("Invalid enumeration value '%s' for enumeration PhysicsCollisionShape::Type.", s);
     return PhysicsCollisionShape::SHAPE_BOX;
 }
 
-std::string lua_stringFromEnum_PhysicsCollisionShapeType(PhysicsCollisionShape::Type e)
+const char* lua_stringFromEnum_PhysicsCollisionShapeType(PhysicsCollisionShape::Type e)
 {
     if (e == PhysicsCollisionShape::SHAPE_BOX)
-        return std::string("SHAPE_BOX");
+        return luaEnumString_PhysicsCollisionShapeType_SHAPE_BOX;
     if (e == PhysicsCollisionShape::SHAPE_SPHERE)
-        return std::string("SHAPE_SPHERE");
+        return luaEnumString_PhysicsCollisionShapeType_SHAPE_SPHERE;
     if (e == PhysicsCollisionShape::SHAPE_CAPSULE)
-        return std::string("SHAPE_CAPSULE");
+        return luaEnumString_PhysicsCollisionShapeType_SHAPE_CAPSULE;
     if (e == PhysicsCollisionShape::SHAPE_MESH)
-        return std::string("SHAPE_MESH");
+        return luaEnumString_PhysicsCollisionShapeType_SHAPE_MESH;
     if (e == PhysicsCollisionShape::SHAPE_HEIGHTFIELD)
-        return std::string("SHAPE_HEIGHTFIELD");
+        return luaEnumString_PhysicsCollisionShapeType_SHAPE_HEIGHTFIELD;
     GP_ERROR("Invalid enumeration value '%d' for enumeration PhysicsCollisionShape::Type.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_PhysicsControllerListenerEventType_ACTIVATED = "ACTIVATED";
+static const char* luaEnumString_PhysicsControllerListenerEventType_DEACTIVATED = "DEACTIVATED";
+
 PhysicsController::Listener::EventType lua_enumFromString_PhysicsControllerListenerEventType(const char* s)
 {
-    if (strcmp(s, "ACTIVATED") == 0)
+    if (strcmp(s, luaEnumString_PhysicsControllerListenerEventType_ACTIVATED) == 0)
         return PhysicsController::Listener::ACTIVATED;
-    if (strcmp(s, "DEACTIVATED") == 0)
+    if (strcmp(s, luaEnumString_PhysicsControllerListenerEventType_DEACTIVATED) == 0)
         return PhysicsController::Listener::DEACTIVATED;
     GP_ERROR("Invalid enumeration value '%s' for enumeration PhysicsController::Listener::EventType.", s);
     return PhysicsController::Listener::ACTIVATED;
 }
 
-std::string lua_stringFromEnum_PhysicsControllerListenerEventType(PhysicsController::Listener::EventType e)
+const char* lua_stringFromEnum_PhysicsControllerListenerEventType(PhysicsController::Listener::EventType e)
 {
     if (e == PhysicsController::Listener::ACTIVATED)
-        return std::string("ACTIVATED");
+        return luaEnumString_PhysicsControllerListenerEventType_ACTIVATED;
     if (e == PhysicsController::Listener::DEACTIVATED)
-        return std::string("DEACTIVATED");
+        return luaEnumString_PhysicsControllerListenerEventType_DEACTIVATED;
     GP_ERROR("Invalid enumeration value '%d' for enumeration PhysicsController::Listener::EventType.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_PropertiesType_NONE = "NONE";
+static const char* luaEnumString_PropertiesType_STRING = "STRING";
+static const char* luaEnumString_PropertiesType_NUMBER = "NUMBER";
+static const char* luaEnumString_PropertiesType_VECTOR2 = "VECTOR2";
+static const char* luaEnumString_PropertiesType_VECTOR3 = "VECTOR3";
+static const char* luaEnumString_PropertiesType_VECTOR4 = "VECTOR4";
+static const char* luaEnumString_PropertiesType_MATRIX = "MATRIX";
+
 Properties::Type lua_enumFromString_PropertiesType(const char* s)
 {
-    if (strcmp(s, "NONE") == 0)
+    if (strcmp(s, luaEnumString_PropertiesType_NONE) == 0)
         return Properties::NONE;
-    if (strcmp(s, "STRING") == 0)
+    if (strcmp(s, luaEnumString_PropertiesType_STRING) == 0)
         return Properties::STRING;
-    if (strcmp(s, "NUMBER") == 0)
+    if (strcmp(s, luaEnumString_PropertiesType_NUMBER) == 0)
         return Properties::NUMBER;
-    if (strcmp(s, "VECTOR2") == 0)
+    if (strcmp(s, luaEnumString_PropertiesType_VECTOR2) == 0)
         return Properties::VECTOR2;
-    if (strcmp(s, "VECTOR3") == 0)
+    if (strcmp(s, luaEnumString_PropertiesType_VECTOR3) == 0)
         return Properties::VECTOR3;
-    if (strcmp(s, "VECTOR4") == 0)
+    if (strcmp(s, luaEnumString_PropertiesType_VECTOR4) == 0)
         return Properties::VECTOR4;
-    if (strcmp(s, "MATRIX") == 0)
+    if (strcmp(s, luaEnumString_PropertiesType_MATRIX) == 0)
         return Properties::MATRIX;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Properties::Type.", s);
     return Properties::NONE;
 }
 
-std::string lua_stringFromEnum_PropertiesType(Properties::Type e)
+const char* lua_stringFromEnum_PropertiesType(Properties::Type e)
 {
     if (e == Properties::NONE)
-        return std::string("NONE");
+        return luaEnumString_PropertiesType_NONE;
     if (e == Properties::STRING)
-        return std::string("STRING");
+        return luaEnumString_PropertiesType_STRING;
     if (e == Properties::NUMBER)
-        return std::string("NUMBER");
+        return luaEnumString_PropertiesType_NUMBER;
     if (e == Properties::VECTOR2)
-        return std::string("VECTOR2");
+        return luaEnumString_PropertiesType_VECTOR2;
     if (e == Properties::VECTOR3)
-        return std::string("VECTOR3");
+        return luaEnumString_PropertiesType_VECTOR3;
     if (e == Properties::VECTOR4)
-        return std::string("VECTOR4");
+        return luaEnumString_PropertiesType_VECTOR4;
     if (e == Properties::MATRIX)
-        return std::string("MATRIX");
+        return luaEnumString_PropertiesType_MATRIX;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Properties::Type.", e);
-    return std::string();
-}
+    return enumStringEmpty;
+}
+
+static const char* luaEnumString_RenderStateAutoBinding_NONE = "NONE";
+static const char* luaEnumString_RenderStateAutoBinding_WORLD_MATRIX = "WORLD_MATRIX";
+static const char* luaEnumString_RenderStateAutoBinding_VIEW_MATRIX = "VIEW_MATRIX";
+static const char* luaEnumString_RenderStateAutoBinding_PROJECTION_MATRIX = "PROJECTION_MATRIX";
+static const char* luaEnumString_RenderStateAutoBinding_WORLD_VIEW_MATRIX = "WORLD_VIEW_MATRIX";
+static const char* luaEnumString_RenderStateAutoBinding_VIEW_PROJECTION_MATRIX = "VIEW_PROJECTION_MATRIX";
+static const char* luaEnumString_RenderStateAutoBinding_WORLD_VIEW_PROJECTION_MATRIX = "WORLD_VIEW_PROJECTION_MATRIX";
+static const char* luaEnumString_RenderStateAutoBinding_INVERSE_TRANSPOSE_WORLD_MATRIX = "INVERSE_TRANSPOSE_WORLD_MATRIX";
+static const char* luaEnumString_RenderStateAutoBinding_INVERSE_TRANSPOSE_WORLD_VIEW_MATRIX = "INVERSE_TRANSPOSE_WORLD_VIEW_MATRIX";
+static const char* luaEnumString_RenderStateAutoBinding_CAMERA_WORLD_POSITION = "CAMERA_WORLD_POSITION";
+static const char* luaEnumString_RenderStateAutoBinding_CAMERA_VIEW_POSITION = "CAMERA_VIEW_POSITION";
+static const char* luaEnumString_RenderStateAutoBinding_MATRIX_PALETTE = "MATRIX_PALETTE";
 
 RenderState::AutoBinding lua_enumFromString_RenderStateAutoBinding(const char* s)
 {
-    if (strcmp(s, "NONE") == 0)
+    if (strcmp(s, luaEnumString_RenderStateAutoBinding_NONE) == 0)
         return RenderState::NONE;
-    if (strcmp(s, "WORLD_MATRIX") == 0)
+    if (strcmp(s, luaEnumString_RenderStateAutoBinding_WORLD_MATRIX) == 0)
         return RenderState::WORLD_MATRIX;
-    if (strcmp(s, "VIEW_MATRIX") == 0)
+    if (strcmp(s, luaEnumString_RenderStateAutoBinding_VIEW_MATRIX) == 0)
         return RenderState::VIEW_MATRIX;
-    if (strcmp(s, "PROJECTION_MATRIX") == 0)
+    if (strcmp(s, luaEnumString_RenderStateAutoBinding_PROJECTION_MATRIX) == 0)
         return RenderState::PROJECTION_MATRIX;
-    if (strcmp(s, "WORLD_VIEW_MATRIX") == 0)
+    if (strcmp(s, luaEnumString_RenderStateAutoBinding_WORLD_VIEW_MATRIX) == 0)
         return RenderState::WORLD_VIEW_MATRIX;
-    if (strcmp(s, "VIEW_PROJECTION_MATRIX") == 0)
+    if (strcmp(s, luaEnumString_RenderStateAutoBinding_VIEW_PROJECTION_MATRIX) == 0)
         return RenderState::VIEW_PROJECTION_MATRIX;
-    if (strcmp(s, "WORLD_VIEW_PROJECTION_MATRIX") == 0)
+    if (strcmp(s, luaEnumString_RenderStateAutoBinding_WORLD_VIEW_PROJECTION_MATRIX) == 0)
         return RenderState::WORLD_VIEW_PROJECTION_MATRIX;
-    if (strcmp(s, "INVERSE_TRANSPOSE_WORLD_MATRIX") == 0)
+    if (strcmp(s, luaEnumString_RenderStateAutoBinding_INVERSE_TRANSPOSE_WORLD_MATRIX) == 0)
         return RenderState::INVERSE_TRANSPOSE_WORLD_MATRIX;
-    if (strcmp(s, "INVERSE_TRANSPOSE_WORLD_VIEW_MATRIX") == 0)
+    if (strcmp(s, luaEnumString_RenderStateAutoBinding_INVERSE_TRANSPOSE_WORLD_VIEW_MATRIX) == 0)
         return RenderState::INVERSE_TRANSPOSE_WORLD_VIEW_MATRIX;
-    if (strcmp(s, "CAMERA_WORLD_POSITION") == 0)
+    if (strcmp(s, luaEnumString_RenderStateAutoBinding_CAMERA_WORLD_POSITION) == 0)
         return RenderState::CAMERA_WORLD_POSITION;
-    if (strcmp(s, "CAMERA_VIEW_POSITION") == 0)
+    if (strcmp(s, luaEnumString_RenderStateAutoBinding_CAMERA_VIEW_POSITION) == 0)
         return RenderState::CAMERA_VIEW_POSITION;
-    if (strcmp(s, "MATRIX_PALETTE") == 0)
+    if (strcmp(s, luaEnumString_RenderStateAutoBinding_MATRIX_PALETTE) == 0)
         return RenderState::MATRIX_PALETTE;
     GP_ERROR("Invalid enumeration value '%s' for enumeration RenderState::AutoBinding.", s);
     return RenderState::NONE;
 }
 
-std::string lua_stringFromEnum_RenderStateAutoBinding(RenderState::AutoBinding e)
+const char* lua_stringFromEnum_RenderStateAutoBinding(RenderState::AutoBinding e)
 {
     if (e == RenderState::NONE)
-        return std::string("NONE");
+        return luaEnumString_RenderStateAutoBinding_NONE;
     if (e == RenderState::WORLD_MATRIX)
-        return std::string("WORLD_MATRIX");
+        return luaEnumString_RenderStateAutoBinding_WORLD_MATRIX;
     if (e == RenderState::VIEW_MATRIX)
-        return std::string("VIEW_MATRIX");
+        return luaEnumString_RenderStateAutoBinding_VIEW_MATRIX;
     if (e == RenderState::PROJECTION_MATRIX)
-        return std::string("PROJECTION_MATRIX");
+        return luaEnumString_RenderStateAutoBinding_PROJECTION_MATRIX;
     if (e == RenderState::WORLD_VIEW_MATRIX)
-        return std::string("WORLD_VIEW_MATRIX");
+        return luaEnumString_RenderStateAutoBinding_WORLD_VIEW_MATRIX;
     if (e == RenderState::VIEW_PROJECTION_MATRIX)
-        return std::string("VIEW_PROJECTION_MATRIX");
+        return luaEnumString_RenderStateAutoBinding_VIEW_PROJECTION_MATRIX;
     if (e == RenderState::WORLD_VIEW_PROJECTION_MATRIX)
-        return std::string("WORLD_VIEW_PROJECTION_MATRIX");
+        return luaEnumString_RenderStateAutoBinding_WORLD_VIEW_PROJECTION_MATRIX;
     if (e == RenderState::INVERSE_TRANSPOSE_WORLD_MATRIX)
-        return std::string("INVERSE_TRANSPOSE_WORLD_MATRIX");
+        return luaEnumString_RenderStateAutoBinding_INVERSE_TRANSPOSE_WORLD_MATRIX;
     if (e == RenderState::INVERSE_TRANSPOSE_WORLD_VIEW_MATRIX)
-        return std::string("INVERSE_TRANSPOSE_WORLD_VIEW_MATRIX");
+        return luaEnumString_RenderStateAutoBinding_INVERSE_TRANSPOSE_WORLD_VIEW_MATRIX;
     if (e == RenderState::CAMERA_WORLD_POSITION)
-        return std::string("CAMERA_WORLD_POSITION");
+        return luaEnumString_RenderStateAutoBinding_CAMERA_WORLD_POSITION;
     if (e == RenderState::CAMERA_VIEW_POSITION)
-        return std::string("CAMERA_VIEW_POSITION");
+        return luaEnumString_RenderStateAutoBinding_CAMERA_VIEW_POSITION;
     if (e == RenderState::MATRIX_PALETTE)
-        return std::string("MATRIX_PALETTE");
+        return luaEnumString_RenderStateAutoBinding_MATRIX_PALETTE;
     GP_ERROR("Invalid enumeration value '%d' for enumeration RenderState::AutoBinding.", e);
-    return std::string();
-}
+    return enumStringEmpty;
+}
+
+static const char* luaEnumString_RenderStateBlend_BLEND_ZERO = "BLEND_ZERO";
+static const char* luaEnumString_RenderStateBlend_BLEND_ONE = "BLEND_ONE";
+static const char* luaEnumString_RenderStateBlend_BLEND_SRC_COLOR = "BLEND_SRC_COLOR";
+static const char* luaEnumString_RenderStateBlend_BLEN_ONE_MINUS_SRC_COLOR = "BLEN_ONE_MINUS_SRC_COLOR";
+static const char* luaEnumString_RenderStateBlend_BLEND_DST_COLOR = "BLEND_DST_COLOR";
+static const char* luaEnumString_RenderStateBlend_BLEND_ONE_MINUS_DST_COLOR = "BLEND_ONE_MINUS_DST_COLOR";
+static const char* luaEnumString_RenderStateBlend_BLEND_SRC_ALPHA = "BLEND_SRC_ALPHA";
+static const char* luaEnumString_RenderStateBlend_BLEND_ONE_MINUS_SRC_ALPHA = "BLEND_ONE_MINUS_SRC_ALPHA";
+static const char* luaEnumString_RenderStateBlend_BLEND_DST_ALPHA = "BLEND_DST_ALPHA";
+static const char* luaEnumString_RenderStateBlend_BLEND_ONE_MINUS_DST_ALPHA = "BLEND_ONE_MINUS_DST_ALPHA";
+static const char* luaEnumString_RenderStateBlend_BLEND_CONSTANT_ALPHA = "BLEND_CONSTANT_ALPHA";
+static const char* luaEnumString_RenderStateBlend_BLEND_ONE_MINUS_CONSTANT_ALPHA = "BLEND_ONE_MINUS_CONSTANT_ALPHA";
+static const char* luaEnumString_RenderStateBlend_BLEND_SRC_ALPHA_SATURATE = "BLEND_SRC_ALPHA_SATURATE";
 
 RenderState::Blend lua_enumFromString_RenderStateBlend(const char* s)
 {
-    if (strcmp(s, "BLEND_ZERO") == 0)
+    if (strcmp(s, luaEnumString_RenderStateBlend_BLEND_ZERO) == 0)
         return RenderState::BLEND_ZERO;
-    if (strcmp(s, "BLEND_ONE") == 0)
+    if (strcmp(s, luaEnumString_RenderStateBlend_BLEND_ONE) == 0)
         return RenderState::BLEND_ONE;
-    if (strcmp(s, "BLEND_SRC_COLOR") == 0)
+    if (strcmp(s, luaEnumString_RenderStateBlend_BLEND_SRC_COLOR) == 0)
         return RenderState::BLEND_SRC_COLOR;
-    if (strcmp(s, "BLEN_ONE_MINUS_SRC_COLOR") == 0)
+    if (strcmp(s, luaEnumString_RenderStateBlend_BLEN_ONE_MINUS_SRC_COLOR) == 0)
         return RenderState::BLEN_ONE_MINUS_SRC_COLOR;
-    if (strcmp(s, "BLEND_DST_COLOR") == 0)
+    if (strcmp(s, luaEnumString_RenderStateBlend_BLEND_DST_COLOR) == 0)
         return RenderState::BLEND_DST_COLOR;
-    if (strcmp(s, "BLEND_ONE_MINUS_DST_COLOR") == 0)
+    if (strcmp(s, luaEnumString_RenderStateBlend_BLEND_ONE_MINUS_DST_COLOR) == 0)
         return RenderState::BLEND_ONE_MINUS_DST_COLOR;
-    if (strcmp(s, "BLEND_SRC_ALPHA") == 0)
+    if (strcmp(s, luaEnumString_RenderStateBlend_BLEND_SRC_ALPHA) == 0)
         return RenderState::BLEND_SRC_ALPHA;
-    if (strcmp(s, "BLEND_ONE_MINUS_SRC_ALPHA") == 0)
+    if (strcmp(s, luaEnumString_RenderStateBlend_BLEND_ONE_MINUS_SRC_ALPHA) == 0)
         return RenderState::BLEND_ONE_MINUS_SRC_ALPHA;
-    if (strcmp(s, "BLEND_DST_ALPHA") == 0)
+    if (strcmp(s, luaEnumString_RenderStateBlend_BLEND_DST_ALPHA) == 0)
         return RenderState::BLEND_DST_ALPHA;
-    if (strcmp(s, "BLEND_ONE_MINUS_DST_ALPHA") == 0)
+    if (strcmp(s, luaEnumString_RenderStateBlend_BLEND_ONE_MINUS_DST_ALPHA) == 0)
         return RenderState::BLEND_ONE_MINUS_DST_ALPHA;
-    if (strcmp(s, "BLEND_CONSTANT_ALPHA") == 0)
+    if (strcmp(s, luaEnumString_RenderStateBlend_BLEND_CONSTANT_ALPHA) == 0)
         return RenderState::BLEND_CONSTANT_ALPHA;
-    if (strcmp(s, "BLEND_ONE_MINUS_CONSTANT_ALPHA") == 0)
+    if (strcmp(s, luaEnumString_RenderStateBlend_BLEND_ONE_MINUS_CONSTANT_ALPHA) == 0)
         return RenderState::BLEND_ONE_MINUS_CONSTANT_ALPHA;
-    if (strcmp(s, "BLEND_SRC_ALPHA_SATURATE") == 0)
+    if (strcmp(s, luaEnumString_RenderStateBlend_BLEND_SRC_ALPHA_SATURATE) == 0)
         return RenderState::BLEND_SRC_ALPHA_SATURATE;
     GP_ERROR("Invalid enumeration value '%s' for enumeration RenderState::Blend.", s);
     return RenderState::BLEND_ZERO;
 }
 
-std::string lua_stringFromEnum_RenderStateBlend(RenderState::Blend e)
+const char* lua_stringFromEnum_RenderStateBlend(RenderState::Blend e)
 {
     if (e == RenderState::BLEND_ZERO)
-        return std::string("BLEND_ZERO");
+        return luaEnumString_RenderStateBlend_BLEND_ZERO;
     if (e == RenderState::BLEND_ONE)
-        return std::string("BLEND_ONE");
+        return luaEnumString_RenderStateBlend_BLEND_ONE;
     if (e == RenderState::BLEND_SRC_COLOR)
-        return std::string("BLEND_SRC_COLOR");
+        return luaEnumString_RenderStateBlend_BLEND_SRC_COLOR;
     if (e == RenderState::BLEN_ONE_MINUS_SRC_COLOR)
-        return std::string("BLEN_ONE_MINUS_SRC_COLOR");
+        return luaEnumString_RenderStateBlend_BLEN_ONE_MINUS_SRC_COLOR;
     if (e == RenderState::BLEND_DST_COLOR)
-        return std::string("BLEND_DST_COLOR");
+        return luaEnumString_RenderStateBlend_BLEND_DST_COLOR;
     if (e == RenderState::BLEND_ONE_MINUS_DST_COLOR)
-        return std::string("BLEND_ONE_MINUS_DST_COLOR");
+        return luaEnumString_RenderStateBlend_BLEND_ONE_MINUS_DST_COLOR;
     if (e == RenderState::BLEND_SRC_ALPHA)
-        return std::string("BLEND_SRC_ALPHA");
+        return luaEnumString_RenderStateBlend_BLEND_SRC_ALPHA;
     if (e == RenderState::BLEND_ONE_MINUS_SRC_ALPHA)
-        return std::string("BLEND_ONE_MINUS_SRC_ALPHA");
+        return luaEnumString_RenderStateBlend_BLEND_ONE_MINUS_SRC_ALPHA;
     if (e == RenderState::BLEND_DST_ALPHA)
-        return std::string("BLEND_DST_ALPHA");
+        return luaEnumString_RenderStateBlend_BLEND_DST_ALPHA;
     if (e == RenderState::BLEND_ONE_MINUS_DST_ALPHA)
-        return std::string("BLEND_ONE_MINUS_DST_ALPHA");
+        return luaEnumString_RenderStateBlend_BLEND_ONE_MINUS_DST_ALPHA;
     if (e == RenderState::BLEND_CONSTANT_ALPHA)
-        return std::string("BLEND_CONSTANT_ALPHA");
+        return luaEnumString_RenderStateBlend_BLEND_CONSTANT_ALPHA;
     if (e == RenderState::BLEND_ONE_MINUS_CONSTANT_ALPHA)
-        return std::string("BLEND_ONE_MINUS_CONSTANT_ALPHA");
+        return luaEnumString_RenderStateBlend_BLEND_ONE_MINUS_CONSTANT_ALPHA;
     if (e == RenderState::BLEND_SRC_ALPHA_SATURATE)
-        return std::string("BLEND_SRC_ALPHA_SATURATE");
+        return luaEnumString_RenderStateBlend_BLEND_SRC_ALPHA_SATURATE;
     GP_ERROR("Invalid enumeration value '%d' for enumeration RenderState::Blend.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_SceneDebugFlags_DEBUG_BOXES = "DEBUG_BOXES";
+static const char* luaEnumString_SceneDebugFlags_DEBUG_SPHERES = "DEBUG_SPHERES";
+
 Scene::DebugFlags lua_enumFromString_SceneDebugFlags(const char* s)
 {
-    if (strcmp(s, "DEBUG_BOXES") == 0)
+    if (strcmp(s, luaEnumString_SceneDebugFlags_DEBUG_BOXES) == 0)
         return Scene::DEBUG_BOXES;
-    if (strcmp(s, "DEBUG_SPHERES") == 0)
+    if (strcmp(s, luaEnumString_SceneDebugFlags_DEBUG_SPHERES) == 0)
         return Scene::DEBUG_SPHERES;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Scene::DebugFlags.", s);
     return Scene::DEBUG_BOXES;
 }
 
-std::string lua_stringFromEnum_SceneDebugFlags(Scene::DebugFlags e)
+const char* lua_stringFromEnum_SceneDebugFlags(Scene::DebugFlags e)
 {
     if (e == Scene::DEBUG_BOXES)
-        return std::string("DEBUG_BOXES");
+        return luaEnumString_SceneDebugFlags_DEBUG_BOXES;
     if (e == Scene::DEBUG_SPHERES)
-        return std::string("DEBUG_SPHERES");
+        return luaEnumString_SceneDebugFlags_DEBUG_SPHERES;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Scene::DebugFlags.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_TextureFilter_NEAREST = "NEAREST";
+static const char* luaEnumString_TextureFilter_LINEAR = "LINEAR";
+static const char* luaEnumString_TextureFilter_NEAREST_MIPMAP_NEAREST = "NEAREST_MIPMAP_NEAREST";
+static const char* luaEnumString_TextureFilter_LINEAR_MIPMAP_NEAREST = "LINEAR_MIPMAP_NEAREST";
+static const char* luaEnumString_TextureFilter_NEAREST_MIPMAP_LINEAR = "NEAREST_MIPMAP_LINEAR";
+static const char* luaEnumString_TextureFilter_LINEAR_MIPMAP_LINEAR = "LINEAR_MIPMAP_LINEAR";
+
 Texture::Filter lua_enumFromString_TextureFilter(const char* s)
 {
-    if (strcmp(s, "NEAREST") == 0)
+    if (strcmp(s, luaEnumString_TextureFilter_NEAREST) == 0)
         return Texture::NEAREST;
-    if (strcmp(s, "LINEAR") == 0)
+    if (strcmp(s, luaEnumString_TextureFilter_LINEAR) == 0)
         return Texture::LINEAR;
-    if (strcmp(s, "NEAREST_MIPMAP_NEAREST") == 0)
+    if (strcmp(s, luaEnumString_TextureFilter_NEAREST_MIPMAP_NEAREST) == 0)
         return Texture::NEAREST_MIPMAP_NEAREST;
-    if (strcmp(s, "LINEAR_MIPMAP_NEAREST") == 0)
+    if (strcmp(s, luaEnumString_TextureFilter_LINEAR_MIPMAP_NEAREST) == 0)
         return Texture::LINEAR_MIPMAP_NEAREST;
-    if (strcmp(s, "NEAREST_MIPMAP_LINEAR") == 0)
+    if (strcmp(s, luaEnumString_TextureFilter_NEAREST_MIPMAP_LINEAR) == 0)
         return Texture::NEAREST_MIPMAP_LINEAR;
-    if (strcmp(s, "LINEAR_MIPMAP_LINEAR") == 0)
+    if (strcmp(s, luaEnumString_TextureFilter_LINEAR_MIPMAP_LINEAR) == 0)
         return Texture::LINEAR_MIPMAP_LINEAR;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Texture::Filter.", s);
     return Texture::NEAREST;
 }
 
-std::string lua_stringFromEnum_TextureFilter(Texture::Filter e)
+const char* lua_stringFromEnum_TextureFilter(Texture::Filter e)
 {
     if (e == Texture::NEAREST)
-        return std::string("NEAREST");
+        return luaEnumString_TextureFilter_NEAREST;
     if (e == Texture::LINEAR)
-        return std::string("LINEAR");
+        return luaEnumString_TextureFilter_LINEAR;
     if (e == Texture::NEAREST_MIPMAP_NEAREST)
-        return std::string("NEAREST_MIPMAP_NEAREST");
+        return luaEnumString_TextureFilter_NEAREST_MIPMAP_NEAREST;
     if (e == Texture::LINEAR_MIPMAP_NEAREST)
-        return std::string("LINEAR_MIPMAP_NEAREST");
+        return luaEnumString_TextureFilter_LINEAR_MIPMAP_NEAREST;
     if (e == Texture::NEAREST_MIPMAP_LINEAR)
-        return std::string("NEAREST_MIPMAP_LINEAR");
+        return luaEnumString_TextureFilter_NEAREST_MIPMAP_LINEAR;
     if (e == Texture::LINEAR_MIPMAP_LINEAR)
-        return std::string("LINEAR_MIPMAP_LINEAR");
+        return luaEnumString_TextureFilter_LINEAR_MIPMAP_LINEAR;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Texture::Filter.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_TextureFormat_RGB = "RGB";
+static const char* luaEnumString_TextureFormat_RGBA = "RGBA";
+static const char* luaEnumString_TextureFormat_ALPHA = "ALPHA";
+
 Texture::Format lua_enumFromString_TextureFormat(const char* s)
 {
-    if (strcmp(s, "RGB") == 0)
+    if (strcmp(s, luaEnumString_TextureFormat_RGB) == 0)
         return Texture::RGB;
-    if (strcmp(s, "RGBA") == 0)
+    if (strcmp(s, luaEnumString_TextureFormat_RGBA) == 0)
         return Texture::RGBA;
-    if (strcmp(s, "ALPHA") == 0)
+    if (strcmp(s, luaEnumString_TextureFormat_ALPHA) == 0)
         return Texture::ALPHA;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Texture::Format.", s);
     return Texture::RGB;
 }
 
-std::string lua_stringFromEnum_TextureFormat(Texture::Format e)
+const char* lua_stringFromEnum_TextureFormat(Texture::Format e)
 {
     if (e == Texture::RGB)
-        return std::string("RGB");
+        return luaEnumString_TextureFormat_RGB;
     if (e == Texture::RGBA)
-        return std::string("RGBA");
+        return luaEnumString_TextureFormat_RGBA;
     if (e == Texture::ALPHA)
-        return std::string("ALPHA");
+        return luaEnumString_TextureFormat_ALPHA;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Texture::Format.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_TextureWrap_REPEAT = "REPEAT";
+static const char* luaEnumString_TextureWrap_CLAMP = "CLAMP";
+
 Texture::Wrap lua_enumFromString_TextureWrap(const char* s)
 {
-    if (strcmp(s, "REPEAT") == 0)
+    if (strcmp(s, luaEnumString_TextureWrap_REPEAT) == 0)
         return Texture::REPEAT;
-    if (strcmp(s, "CLAMP") == 0)
+    if (strcmp(s, luaEnumString_TextureWrap_CLAMP) == 0)
         return Texture::CLAMP;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Texture::Wrap.", s);
     return Texture::REPEAT;
 }
 
-std::string lua_stringFromEnum_TextureWrap(Texture::Wrap e)
+const char* lua_stringFromEnum_TextureWrap(Texture::Wrap e)
 {
     if (e == Texture::REPEAT)
-        return std::string("REPEAT");
+        return luaEnumString_TextureWrap_REPEAT;
     if (e == Texture::CLAMP)
-        return std::string("CLAMP");
+        return luaEnumString_TextureWrap_CLAMP;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Texture::Wrap.", e);
-    return std::string();
+    return enumStringEmpty;
 }
 
+static const char* luaEnumString_TouchTouchEvent_TOUCH_PRESS = "TOUCH_PRESS";
+static const char* luaEnumString_TouchTouchEvent_TOUCH_RELEASE = "TOUCH_RELEASE";
+static const char* luaEnumString_TouchTouchEvent_TOUCH_MOVE = "TOUCH_MOVE";
+
 Touch::TouchEvent lua_enumFromString_TouchTouchEvent(const char* s)
 {
-    if (strcmp(s, "TOUCH_PRESS") == 0)
+    if (strcmp(s, luaEnumString_TouchTouchEvent_TOUCH_PRESS) == 0)
         return Touch::TOUCH_PRESS;
-    if (strcmp(s, "TOUCH_RELEASE") == 0)
+    if (strcmp(s, luaEnumString_TouchTouchEvent_TOUCH_RELEASE) == 0)
         return Touch::TOUCH_RELEASE;
-    if (strcmp(s, "TOUCH_MOVE") == 0)
+    if (strcmp(s, luaEnumString_TouchTouchEvent_TOUCH_MOVE) == 0)
         return Touch::TOUCH_MOVE;
     GP_ERROR("Invalid enumeration value '%s' for enumeration Touch::TouchEvent.", s);
     return Touch::TOUCH_PRESS;
 }
 
-std::string lua_stringFromEnum_TouchTouchEvent(Touch::TouchEvent e)
+const char* lua_stringFromEnum_TouchTouchEvent(Touch::TouchEvent e)
 {
     if (e == Touch::TOUCH_PRESS)
-        return std::string("TOUCH_PRESS");
+        return luaEnumString_TouchTouchEvent_TOUCH_PRESS;
     if (e == Touch::TOUCH_RELEASE)
-        return std::string("TOUCH_RELEASE");
+        return luaEnumString_TouchTouchEvent_TOUCH_RELEASE;
     if (e == Touch::TOUCH_MOVE)
-        return std::string("TOUCH_MOVE");
+        return luaEnumString_TouchTouchEvent_TOUCH_MOVE;
     GP_ERROR("Invalid enumeration value '%d' for enumeration Touch::TouchEvent.", e);
-    return std::string();
-}
+    return enumStringEmpty;
+}
+
+static const char* luaEnumString_VertexFormatUsage_POSITION = "POSITION";
+static const char* luaEnumString_VertexFormatUsage_NORMAL = "NORMAL";
+static const char* luaEnumString_VertexFormatUsage_COLOR = "COLOR";
+static const char* luaEnumString_VertexFormatUsage_TANGENT = "TANGENT";
+static const char* luaEnumString_VertexFormatUsage_BINORMAL = "BINORMAL";
+static const char* luaEnumString_VertexFormatUsage_BLENDWEIGHTS = "BLENDWEIGHTS";
+static const char* luaEnumString_VertexFormatUsage_BLENDINDICES = "BLENDINDICES";
+static const char* luaEnumString_VertexFormatUsage_TEXCOORD0 = "TEXCOORD0";
+static const char* luaEnumString_VertexFormatUsage_TEXCOORD1 = "TEXCOORD1";
+static const char* luaEnumString_VertexFormatUsage_TEXCOORD2 = "TEXCOORD2";
+static const char* luaEnumString_VertexFormatUsage_TEXCOORD3 = "TEXCOORD3";
+static const char* luaEnumString_VertexFormatUsage_TEXCOORD4 = "TEXCOORD4";
+static const char* luaEnumString_VertexFormatUsage_TEXCOORD5 = "TEXCOORD5";
+static const char* luaEnumString_VertexFormatUsage_TEXCOORD6 = "TEXCOORD6";
+static const char* luaEnumString_VertexFormatUsage_TEXCOORD7 = "TEXCOORD7";
 
 VertexFormat::Usage lua_enumFromString_VertexFormatUsage(const char* s)
 {
-    if (strcmp(s, "POSITION") == 0)
+    if (strcmp(s, luaEnumString_VertexFormatUsage_POSITION) == 0)
         return VertexFormat::POSITION;
-    if (strcmp(s, "NORMAL") == 0)
+    if (strcmp(s, luaEnumString_VertexFormatUsage_NORMAL) == 0)
         return VertexFormat::NORMAL;
-    if (strcmp(s, "COLOR") == 0)
+    if (strcmp(s, luaEnumString_VertexFormatUsage_COLOR) == 0)
         return VertexFormat::COLOR;
-    if (strcmp(s, "TANGENT") == 0)
+    if (strcmp(s, luaEnumString_VertexFormatUsage_TANGENT) == 0)
         return VertexFormat::TANGENT;
-    if (strcmp(s, "BINORMAL") == 0)
+    if (strcmp(s, luaEnumString_VertexFormatUsage_BINORMAL) == 0)
         return VertexFormat::BINORMAL;
-    if (strcmp(s, "BLENDWEIGHTS") == 0)
+    if (strcmp(s, luaEnumString_VertexFormatUsage_BLENDWEIGHTS) == 0)
         return VertexFormat::BLENDWEIGHTS;
-    if (strcmp(s, "BLENDINDICES") == 0)
+    if (strcmp(s, luaEnumString_VertexFormatUsage_BLENDINDICES) == 0)
         return VertexFormat::BLENDINDICES;
-    if (strcmp(s, "TEXCOORD0") == 0)
+    if (strcmp(s, luaEnumString_VertexFormatUsage_TEXCOORD0) == 0)
         return VertexFormat::TEXCOORD0;
-    if (strcmp(s, "TEXCOORD1") == 0)
+    if (strcmp(s, luaEnumString_VertexFormatUsage_TEXCOORD1) == 0)
         return VertexFormat::TEXCOORD1;
-    if (strcmp(s, "TEXCOORD2") == 0)
+    if (strcmp(s, luaEnumString_VertexFormatUsage_TEXCOORD2) == 0)
         return VertexFormat::TEXCOORD2;
-    if (strcmp(s, "TEXCOORD3") == 0)
+    if (strcmp(s, luaEnumString_VertexFormatUsage_TEXCOORD3) == 0)
         return VertexFormat::TEXCOORD3;
-    if (strcmp(s, "TEXCOORD4") == 0)
+    if (strcmp(s, luaEnumString_VertexFormatUsage_TEXCOORD4) == 0)
         return VertexFormat::TEXCOORD4;
-    if (strcmp(s, "TEXCOORD5") == 0)
+    if (strcmp(s, luaEnumString_VertexFormatUsage_TEXCOORD5) == 0)
         return VertexFormat::TEXCOORD5;
-    if (strcmp(s, "TEXCOORD6") == 0)
+    if (strcmp(s, luaEnumString_VertexFormatUsage_TEXCOORD6) == 0)
         return VertexFormat::TEXCOORD6;
-    if (strcmp(s, "TEXCOORD7") == 0)
+    if (strcmp(s, luaEnumString_VertexFormatUsage_TEXCOORD7) == 0)
         return VertexFormat::TEXCOORD7;
     GP_ERROR("Invalid enumeration value '%s' for enumeration VertexFormat::Usage.", s);
     return VertexFormat::POSITION;
 }
 
-std::string lua_stringFromEnum_VertexFormatUsage(VertexFormat::Usage e)
+const char* lua_stringFromEnum_VertexFormatUsage(VertexFormat::Usage e)
 {
     if (e == VertexFormat::POSITION)
-        return std::string("POSITION");
+        return luaEnumString_VertexFormatUsage_POSITION;
     if (e == VertexFormat::NORMAL)
-        return std::string("NORMAL");
+        return luaEnumString_VertexFormatUsage_NORMAL;
     if (e == VertexFormat::COLOR)
-        return std::string("COLOR");
+        return luaEnumString_VertexFormatUsage_COLOR;
     if (e == VertexFormat::TANGENT)
-        return std::string("TANGENT");
+        return luaEnumString_VertexFormatUsage_TANGENT;
     if (e == VertexFormat::BINORMAL)
-        return std::string("BINORMAL");
+        return luaEnumString_VertexFormatUsage_BINORMAL;
     if (e == VertexFormat::BLENDWEIGHTS)
-        return std::string("BLENDWEIGHTS");
+        return luaEnumString_VertexFormatUsage_BLENDWEIGHTS;
     if (e == VertexFormat::BLENDINDICES)
-        return std::string("BLENDINDICES");
+        return luaEnumString_VertexFormatUsage_BLENDINDICES;
     if (e == VertexFormat::TEXCOORD0)
-        return std::string("TEXCOORD0");
+        return luaEnumString_VertexFormatUsage_TEXCOORD0;
     if (e == VertexFormat::TEXCOORD1)
-        return std::string("TEXCOORD1");
+        return luaEnumString_VertexFormatUsage_TEXCOORD1;
     if (e == VertexFormat::TEXCOORD2)
-        return std::string("TEXCOORD2");
+        return luaEnumString_VertexFormatUsage_TEXCOORD2;
     if (e == VertexFormat::TEXCOORD3)
-        return std::string("TEXCOORD3");
+        return luaEnumString_VertexFormatUsage_TEXCOORD3;
     if (e == VertexFormat::TEXCOORD4)
-        return std::string("TEXCOORD4");
+        return luaEnumString_VertexFormatUsage_TEXCOORD4;
     if (e == VertexFormat::TEXCOORD5)
-        return std::string("TEXCOORD5");
+        return luaEnumString_VertexFormatUsage_TEXCOORD5;
     if (e == VertexFormat::TEXCOORD6)
-        return std::string("TEXCOORD6");
+        return luaEnumString_VertexFormatUsage_TEXCOORD6;
     if (e == VertexFormat::TEXCOORD7)
-        return std::string("TEXCOORD7");
+        return luaEnumString_VertexFormatUsage_TEXCOORD7;
     GP_ERROR("Invalid enumeration value '%d' for enumeration VertexFormat::Usage.", e);
-    return std::string();
+    return enumStringEmpty;
+}
+
+const char* lua_stringFromEnumGlobal(std::string& enumname, unsigned int value)
+{
+    if (enumname == "AnimationClip::Listener::EventType")
+        return lua_stringFromEnum_AnimationClipListenerEventType((AnimationClip::Listener::EventType)value);
+    if (enumname == "AudioSource::State")
+        return lua_stringFromEnum_AudioSourceState((AudioSource::State)value);
+    if (enumname == "Camera::Type")
+        return lua_stringFromEnum_CameraType((Camera::Type)value);
+    if (enumname == "Container::Scroll")
+        return lua_stringFromEnum_ContainerScroll((Container::Scroll)value);
+    if (enumname == "Control::Alignment")
+        return lua_stringFromEnum_ControlAlignment((Control::Alignment)value);
+    if (enumname == "Control::Listener::EventType")
+        return lua_stringFromEnum_ControlListenerEventType((Control::Listener::EventType)value);
+    if (enumname == "Control::State")
+        return lua_stringFromEnum_ControlState((Control::State)value);
+    if (enumname == "Curve::InterpolationType")
+        return lua_stringFromEnum_CurveInterpolationType((Curve::InterpolationType)value);
+    if (enumname == "DepthStencilTarget::Format")
+        return lua_stringFromEnum_DepthStencilTargetFormat((DepthStencilTarget::Format)value);
+    if (enumname == "Font::Justify")
+        return lua_stringFromEnum_FontJustify((Font::Justify)value);
+    if (enumname == "Font::Style")
+        return lua_stringFromEnum_FontStyle((Font::Style)value);
+    if (enumname == "Game::ClearFlags")
+        return lua_stringFromEnum_GameClearFlags((Game::ClearFlags)value);
+    if (enumname == "Game::State")
+        return lua_stringFromEnum_GameState((Game::State)value);
+    if (enumname == "Gamepad::ButtonState")
+        return lua_stringFromEnum_GamepadButtonState((Gamepad::ButtonState)value);
+    if (enumname == "Gamepad::GamepadEvent")
+        return lua_stringFromEnum_GamepadGamepadEvent((Gamepad::GamepadEvent)value);
+    if (enumname == "Image::Format")
+        return lua_stringFromEnum_ImageFormat((Image::Format)value);
+    if (enumname == "Keyboard::Key")
+        return lua_stringFromEnum_KeyboardKey((Keyboard::Key)value);
+    if (enumname == "Keyboard::KeyEvent")
+        return lua_stringFromEnum_KeyboardKeyEvent((Keyboard::KeyEvent)value);
+    if (enumname == "Layout::Type")
+        return lua_stringFromEnum_LayoutType((Layout::Type)value);
+    if (enumname == "Light::Type")
+        return lua_stringFromEnum_LightType((Light::Type)value);
+    if (enumname == "Mesh::IndexFormat")
+        return lua_stringFromEnum_MeshIndexFormat((Mesh::IndexFormat)value);
+    if (enumname == "Mesh::PrimitiveType")
+        return lua_stringFromEnum_MeshPrimitiveType((Mesh::PrimitiveType)value);
+    if (enumname == "Mouse::MouseEvent")
+        return lua_stringFromEnum_MouseMouseEvent((Mouse::MouseEvent)value);
+    if (enumname == "Node::Type")
+        return lua_stringFromEnum_NodeType((Node::Type)value);
+    if (enumname == "ParticleEmitter::TextureBlending")
+        return lua_stringFromEnum_ParticleEmitterTextureBlending((ParticleEmitter::TextureBlending)value);
+    if (enumname == "PhysicsCollisionObject::CollisionListener::EventType")
+        return lua_stringFromEnum_PhysicsCollisionObjectCollisionListenerEventType((PhysicsCollisionObject::CollisionListener::EventType)value);
+    if (enumname == "PhysicsCollisionObject::Type")
+        return lua_stringFromEnum_PhysicsCollisionObjectType((PhysicsCollisionObject::Type)value);
+    if (enumname == "PhysicsCollisionShape::Type")
+        return lua_stringFromEnum_PhysicsCollisionShapeType((PhysicsCollisionShape::Type)value);
+    if (enumname == "PhysicsController::Listener::EventType")
+        return lua_stringFromEnum_PhysicsControllerListenerEventType((PhysicsController::Listener::EventType)value);
+    if (enumname == "Properties::Type")
+        return lua_stringFromEnum_PropertiesType((Properties::Type)value);
+    if (enumname == "RenderState::AutoBinding")
+        return lua_stringFromEnum_RenderStateAutoBinding((RenderState::AutoBinding)value);
+    if (enumname == "RenderState::Blend")
+        return lua_stringFromEnum_RenderStateBlend((RenderState::Blend)value);
+    if (enumname == "Scene::DebugFlags")
+        return lua_stringFromEnum_SceneDebugFlags((Scene::DebugFlags)value);
+    if (enumname == "Texture::Filter")
+        return lua_stringFromEnum_TextureFilter((Texture::Filter)value);
+    if (enumname == "Texture::Format")
+        return lua_stringFromEnum_TextureFormat((Texture::Format)value);
+    if (enumname == "Texture::Wrap")
+        return lua_stringFromEnum_TextureWrap((Texture::Wrap)value);
+    if (enumname == "Touch::TouchEvent")
+        return lua_stringFromEnum_TouchTouchEvent((Touch::TouchEvent)value);
+    if (enumname == "VertexFormat::Usage")
+        return lua_stringFromEnum_VertexFormatUsage((VertexFormat::Usage)value);
+
+    GP_ERROR("Unrecognized enumeration type '%s'.", enumname.c_str());
+    return enumStringEmpty;
 }
 
 }

gameplay/src/lua/lua_Global.h

@@ -109,81 +109,83 @@ int lua__printError(lua_State* state);
 
 // Lua bindings for enum conversion functions.
 AnimationClip::Listener::EventType lua_enumFromString_AnimationClipListenerEventType(const char* s);
-std::string lua_stringFromEnum_AnimationClipListenerEventType(AnimationClip::Listener::EventType e);
+const char* lua_stringFromEnum_AnimationClipListenerEventType(AnimationClip::Listener::EventType e);
 AudioSource::State lua_enumFromString_AudioSourceState(const char* s);
-std::string lua_stringFromEnum_AudioSourceState(AudioSource::State e);
+const char* lua_stringFromEnum_AudioSourceState(AudioSource::State e);
 Camera::Type lua_enumFromString_CameraType(const char* s);
-std::string lua_stringFromEnum_CameraType(Camera::Type e);
+const char* lua_stringFromEnum_CameraType(Camera::Type e);
 Container::Scroll lua_enumFromString_ContainerScroll(const char* s);
-std::string lua_stringFromEnum_ContainerScroll(Container::Scroll e);
+const char* lua_stringFromEnum_ContainerScroll(Container::Scroll e);
 Control::Alignment lua_enumFromString_ControlAlignment(const char* s);
-std::string lua_stringFromEnum_ControlAlignment(Control::Alignment e);
+const char* lua_stringFromEnum_ControlAlignment(Control::Alignment e);
 Control::Listener::EventType lua_enumFromString_ControlListenerEventType(const char* s);
-std::string lua_stringFromEnum_ControlListenerEventType(Control::Listener::EventType e);
+const char* lua_stringFromEnum_ControlListenerEventType(Control::Listener::EventType e);
 Control::State lua_enumFromString_ControlState(const char* s);
-std::string lua_stringFromEnum_ControlState(Control::State e);
+const char* lua_stringFromEnum_ControlState(Control::State e);
 Curve::InterpolationType lua_enumFromString_CurveInterpolationType(const char* s);
-std::string lua_stringFromEnum_CurveInterpolationType(Curve::InterpolationType e);
+const char* lua_stringFromEnum_CurveInterpolationType(Curve::InterpolationType e);
 DepthStencilTarget::Format lua_enumFromString_DepthStencilTargetFormat(const char* s);
-std::string lua_stringFromEnum_DepthStencilTargetFormat(DepthStencilTarget::Format e);
+const char* lua_stringFromEnum_DepthStencilTargetFormat(DepthStencilTarget::Format e);
 Font::Justify lua_enumFromString_FontJustify(const char* s);
-std::string lua_stringFromEnum_FontJustify(Font::Justify e);
+const char* lua_stringFromEnum_FontJustify(Font::Justify e);
 Font::Style lua_enumFromString_FontStyle(const char* s);
-std::string lua_stringFromEnum_FontStyle(Font::Style e);
+const char* lua_stringFromEnum_FontStyle(Font::Style e);
 Game::ClearFlags lua_enumFromString_GameClearFlags(const char* s);
-std::string lua_stringFromEnum_GameClearFlags(Game::ClearFlags e);
+const char* lua_stringFromEnum_GameClearFlags(Game::ClearFlags e);
 Game::State lua_enumFromString_GameState(const char* s);
-std::string lua_stringFromEnum_GameState(Game::State e);
+const char* lua_stringFromEnum_GameState(Game::State e);
 Gamepad::ButtonState lua_enumFromString_GamepadButtonState(const char* s);
-std::string lua_stringFromEnum_GamepadButtonState(Gamepad::ButtonState e);
+const char* lua_stringFromEnum_GamepadButtonState(Gamepad::ButtonState e);
 Gamepad::GamepadEvent lua_enumFromString_GamepadGamepadEvent(const char* s);
-std::string lua_stringFromEnum_GamepadGamepadEvent(Gamepad::GamepadEvent e);
+const char* lua_stringFromEnum_GamepadGamepadEvent(Gamepad::GamepadEvent e);
 Image::Format lua_enumFromString_ImageFormat(const char* s);
-std::string lua_stringFromEnum_ImageFormat(Image::Format e);
+const char* lua_stringFromEnum_ImageFormat(Image::Format e);
 Keyboard::Key lua_enumFromString_KeyboardKey(const char* s);
-std::string lua_stringFromEnum_KeyboardKey(Keyboard::Key e);
+const char* lua_stringFromEnum_KeyboardKey(Keyboard::Key e);
 Keyboard::KeyEvent lua_enumFromString_KeyboardKeyEvent(const char* s);
-std::string lua_stringFromEnum_KeyboardKeyEvent(Keyboard::KeyEvent e);
+const char* lua_stringFromEnum_KeyboardKeyEvent(Keyboard::KeyEvent e);
 Layout::Type lua_enumFromString_LayoutType(const char* s);
-std::string lua_stringFromEnum_LayoutType(Layout::Type e);
+const char* lua_stringFromEnum_LayoutType(Layout::Type e);
 Light::Type lua_enumFromString_LightType(const char* s);
-std::string lua_stringFromEnum_LightType(Light::Type e);
+const char* lua_stringFromEnum_LightType(Light::Type e);
 Mesh::IndexFormat lua_enumFromString_MeshIndexFormat(const char* s);
-std::string lua_stringFromEnum_MeshIndexFormat(Mesh::IndexFormat e);
+const char* lua_stringFromEnum_MeshIndexFormat(Mesh::IndexFormat e);
 Mesh::PrimitiveType lua_enumFromString_MeshPrimitiveType(const char* s);
-std::string lua_stringFromEnum_MeshPrimitiveType(Mesh::PrimitiveType e);
+const char* lua_stringFromEnum_MeshPrimitiveType(Mesh::PrimitiveType e);
 Mouse::MouseEvent lua_enumFromString_MouseMouseEvent(const char* s);
-std::string lua_stringFromEnum_MouseMouseEvent(Mouse::MouseEvent e);
+const char* lua_stringFromEnum_MouseMouseEvent(Mouse::MouseEvent e);
 Node::Type lua_enumFromString_NodeType(const char* s);
-std::string lua_stringFromEnum_NodeType(Node::Type e);
+const char* lua_stringFromEnum_NodeType(Node::Type e);
 ParticleEmitter::TextureBlending lua_enumFromString_ParticleEmitterTextureBlending(const char* s);
-std::string lua_stringFromEnum_ParticleEmitterTextureBlending(ParticleEmitter::TextureBlending e);
+const char* lua_stringFromEnum_ParticleEmitterTextureBlending(ParticleEmitter::TextureBlending e);
 PhysicsCollisionObject::CollisionListener::EventType lua_enumFromString_PhysicsCollisionObjectCollisionListenerEventType(const char* s);
-std::string lua_stringFromEnum_PhysicsCollisionObjectCollisionListenerEventType(PhysicsCollisionObject::CollisionListener::EventType e);
+const char* lua_stringFromEnum_PhysicsCollisionObjectCollisionListenerEventType(PhysicsCollisionObject::CollisionListener::EventType e);
 PhysicsCollisionObject::Type lua_enumFromString_PhysicsCollisionObjectType(const char* s);
-std::string lua_stringFromEnum_PhysicsCollisionObjectType(PhysicsCollisionObject::Type e);
+const char* lua_stringFromEnum_PhysicsCollisionObjectType(PhysicsCollisionObject::Type e);
 PhysicsCollisionShape::Type lua_enumFromString_PhysicsCollisionShapeType(const char* s);
-std::string lua_stringFromEnum_PhysicsCollisionShapeType(PhysicsCollisionShape::Type e);
+const char* lua_stringFromEnum_PhysicsCollisionShapeType(PhysicsCollisionShape::Type e);
 PhysicsController::Listener::EventType lua_enumFromString_PhysicsControllerListenerEventType(const char* s);
-std::string lua_stringFromEnum_PhysicsControllerListenerEventType(PhysicsController::Listener::EventType e);
+const char* lua_stringFromEnum_PhysicsControllerListenerEventType(PhysicsController::Listener::EventType e);
 Properties::Type lua_enumFromString_PropertiesType(const char* s);
-std::string lua_stringFromEnum_PropertiesType(Properties::Type e);
+const char* lua_stringFromEnum_PropertiesType(Properties::Type e);
 RenderState::AutoBinding lua_enumFromString_RenderStateAutoBinding(const char* s);
-std::string lua_stringFromEnum_RenderStateAutoBinding(RenderState::AutoBinding e);
+const char* lua_stringFromEnum_RenderStateAutoBinding(RenderState::AutoBinding e);
 RenderState::Blend lua_enumFromString_RenderStateBlend(const char* s);
-std::string lua_stringFromEnum_RenderStateBlend(RenderState::Blend e);
+const char* lua_stringFromEnum_RenderStateBlend(RenderState::Blend e);
 Scene::DebugFlags lua_enumFromString_SceneDebugFlags(const char* s);
-std::string lua_stringFromEnum_SceneDebugFlags(Scene::DebugFlags e);
+const char* lua_stringFromEnum_SceneDebugFlags(Scene::DebugFlags e);
 Texture::Filter lua_enumFromString_TextureFilter(const char* s);
-std::string lua_stringFromEnum_TextureFilter(Texture::Filter e);
+const char* lua_stringFromEnum_TextureFilter(Texture::Filter e);
 Texture::Format lua_enumFromString_TextureFormat(const char* s);
-std::string lua_stringFromEnum_TextureFormat(Texture::Format e);
+const char* lua_stringFromEnum_TextureFormat(Texture::Format e);
 Texture::Wrap lua_enumFromString_TextureWrap(const char* s);
-std::string lua_stringFromEnum_TextureWrap(Texture::Wrap e);
+const char* lua_stringFromEnum_TextureWrap(Texture::Wrap e);
 Touch::TouchEvent lua_enumFromString_TouchTouchEvent(const char* s);
-std::string lua_stringFromEnum_TouchTouchEvent(Touch::TouchEvent e);
+const char* lua_stringFromEnum_TouchTouchEvent(Touch::TouchEvent e);
 VertexFormat::Usage lua_enumFromString_VertexFormatUsage(const char* s);
-std::string lua_stringFromEnum_VertexFormatUsage(VertexFormat::Usage e);
+const char* lua_stringFromEnum_VertexFormatUsage(VertexFormat::Usage e);
+
+const char* lua_stringFromEnumGlobal(std::string& enumname, unsigned int value);
 
 void luaRegister_lua_Global();
 

gameplay/src/lua/lua_Image.cpp

@@ -128,7 +128,7 @@ int lua_Image_getFormat(lua_State* state)
                 Image::Format result = instance->getFormat();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ImageFormat(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ImageFormat(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Joint.cpp

@@ -3242,7 +3242,7 @@ int lua_Joint_getType(lua_State* state)
                 Node::Type result = instance->getType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_NodeType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_NodeType(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Joystick.cpp

@@ -707,7 +707,7 @@ int lua_Joystick_getAlignment(lua_State* state)
                 Control::Alignment result = instance->getAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result));
 
                 return 1;
             }
@@ -2184,7 +2184,7 @@ int lua_Joystick_getState(lua_State* state)
                 Control::State result = instance->getState();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlState(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlState(result));
 
                 return 1;
             }
@@ -2267,7 +2267,7 @@ int lua_Joystick_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }
@@ -2290,7 +2290,7 @@ int lua_Joystick_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment(param1);
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Label.cpp

@@ -704,7 +704,7 @@ int lua_Label_getAlignment(lua_State* state)
                 Control::Alignment result = instance->getAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result));
 
                 return 1;
             }
@@ -2135,7 +2135,7 @@ int lua_Label_getState(lua_State* state)
                 Control::State result = instance->getState();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlState(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlState(result));
 
                 return 1;
             }
@@ -2255,7 +2255,7 @@ int lua_Label_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }
@@ -2278,7 +2278,7 @@ int lua_Label_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment(param1);
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Layout.cpp

@@ -159,7 +159,7 @@ int lua_Layout_getType(lua_State* state)
                 Layout::Type result = instance->getType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_LayoutType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_LayoutType(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Light.cpp

@@ -260,7 +260,7 @@ int lua_Light_getLightType(lua_State* state)
                 Light::Type result = instance->getLightType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_LightType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_LightType(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Mesh.cpp

@@ -425,7 +425,7 @@ int lua_Mesh_getPrimitiveType(lua_State* state)
                 Mesh::PrimitiveType result = instance->getPrimitiveType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_MeshPrimitiveType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_MeshPrimitiveType(result));
 
                 return 1;
             }

gameplay/src/lua/lua_MeshPart.cpp

@@ -173,7 +173,7 @@ int lua_MeshPart_getIndexFormat(lua_State* state)
                 Mesh::IndexFormat result = instance->getIndexFormat();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_MeshIndexFormat(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_MeshIndexFormat(result));
 
                 return 1;
             }
@@ -247,7 +247,7 @@ int lua_MeshPart_getPrimitiveType(lua_State* state)
                 Mesh::PrimitiveType result = instance->getPrimitiveType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_MeshPrimitiveType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_MeshPrimitiveType(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Node.cpp

@@ -3196,7 +3196,7 @@ int lua_Node_getType(lua_State* state)
                 Node::Type result = instance->getType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_NodeType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_NodeType(result));
 
                 return 1;
             }

gameplay/src/lua/lua_ParticleEmitter.cpp

@@ -2552,7 +2552,7 @@ int lua_ParticleEmitter_static_getTextureBlendingFromString(lua_State* state)
                 ParticleEmitter::TextureBlending result = ParticleEmitter::getTextureBlendingFromString(param1);
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ParticleEmitterTextureBlending(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ParticleEmitterTextureBlending(result));
 
                 return 1;
             }

gameplay/src/lua/lua_PhysicsCharacter.cpp

@@ -384,7 +384,7 @@ int lua_PhysicsCharacter_getShapeType(lua_State* state)
                 PhysicsCollisionShape::Type result = instance->getShapeType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_PhysicsCollisionShapeType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_PhysicsCollisionShapeType(result));
 
                 return 1;
             }
@@ -421,7 +421,7 @@ int lua_PhysicsCharacter_getType(lua_State* state)
                 PhysicsCollisionObject::Type result = instance->getType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_PhysicsCollisionObjectType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_PhysicsCollisionObjectType(result));
 
                 return 1;
             }

gameplay/src/lua/lua_PhysicsCollisionObject.cpp

@@ -290,7 +290,7 @@ int lua_PhysicsCollisionObject_getShapeType(lua_State* state)
                 PhysicsCollisionShape::Type result = instance->getShapeType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_PhysicsCollisionShapeType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_PhysicsCollisionShapeType(result));
 
                 return 1;
             }
@@ -327,7 +327,7 @@ int lua_PhysicsCollisionObject_getType(lua_State* state)
                 PhysicsCollisionObject::Type result = instance->getType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_PhysicsCollisionObjectType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_PhysicsCollisionObjectType(result));
 
                 return 1;
             }

gameplay/src/lua/lua_PhysicsCollisionShape.cpp

@@ -167,7 +167,7 @@ int lua_PhysicsCollisionShape_getType(lua_State* state)
                 PhysicsCollisionShape::Type result = instance->getType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_PhysicsCollisionShapeType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_PhysicsCollisionShapeType(result));
 
                 return 1;
             }

gameplay/src/lua/lua_PhysicsGhostObject.cpp

@@ -251,7 +251,7 @@ int lua_PhysicsGhostObject_getShapeType(lua_State* state)
                 PhysicsCollisionShape::Type result = instance->getShapeType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_PhysicsCollisionShapeType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_PhysicsCollisionShapeType(result));
 
                 return 1;
             }
@@ -288,7 +288,7 @@ int lua_PhysicsGhostObject_getType(lua_State* state)
                 PhysicsCollisionObject::Type result = instance->getType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_PhysicsCollisionObjectType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_PhysicsCollisionObjectType(result));
 
                 return 1;
             }

gameplay/src/lua/lua_PhysicsRigidBody.cpp

@@ -887,7 +887,7 @@ int lua_PhysicsRigidBody_getShapeType(lua_State* state)
                 PhysicsCollisionShape::Type result = instance->getShapeType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_PhysicsCollisionShapeType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_PhysicsCollisionShapeType(result));
 
                 return 1;
             }
@@ -924,7 +924,7 @@ int lua_PhysicsRigidBody_getType(lua_State* state)
                 PhysicsCollisionObject::Type result = instance->getType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_PhysicsCollisionObjectType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_PhysicsCollisionObjectType(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Properties.cpp

@@ -787,7 +787,7 @@ int lua_Properties_getType(lua_State* state)
                 Properties::Type result = instance->getType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_PropertiesType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_PropertiesType(result));
 
                 return 1;
             }
@@ -810,7 +810,7 @@ int lua_Properties_getType(lua_State* state)
                 Properties::Type result = instance->getType(param1);
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_PropertiesType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_PropertiesType(result));
 
                 return 1;
             }

gameplay/src/lua/lua_RadioButton.cpp

@@ -707,7 +707,7 @@ int lua_RadioButton_getAlignment(lua_State* state)
                 Control::Alignment result = instance->getAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result));
 
                 return 1;
             }
@@ -2184,7 +2184,7 @@ int lua_RadioButton_getState(lua_State* state)
                 Control::State result = instance->getState();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlState(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlState(result));
 
                 return 1;
             }
@@ -2304,7 +2304,7 @@ int lua_RadioButton_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }
@@ -2327,7 +2327,7 @@ int lua_RadioButton_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment(param1);
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Slider.cpp

@@ -712,7 +712,7 @@ int lua_Slider_getAlignment(lua_State* state)
                 Control::Alignment result = instance->getAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result));
 
                 return 1;
             }
@@ -2217,7 +2217,7 @@ int lua_Slider_getState(lua_State* state)
                 Control::State result = instance->getState();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlState(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlState(result));
 
                 return 1;
             }
@@ -2374,7 +2374,7 @@ int lua_Slider_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }
@@ -2397,7 +2397,7 @@ int lua_Slider_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment(param1);
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }

gameplay/src/lua/lua_TextBox.cpp

@@ -705,7 +705,7 @@ int lua_TextBox_getAlignment(lua_State* state)
                 Control::Alignment result = instance->getAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlAlignment(result));
 
                 return 1;
             }
@@ -2173,7 +2173,7 @@ int lua_TextBox_getState(lua_State* state)
                 Control::State result = instance->getState();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_ControlState(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_ControlState(result));
 
                 return 1;
             }
@@ -2293,7 +2293,7 @@ int lua_TextBox_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }
@@ -2316,7 +2316,7 @@ int lua_TextBox_getTextAlignment(lua_State* state)
                 Font::Justify result = instance->getTextAlignment(param1);
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_FontJustify(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_FontJustify(result));
 
                 return 1;
             }

gameplay/src/lua/lua_Texture.cpp

@@ -168,7 +168,7 @@ int lua_Texture_getFormat(lua_State* state)
                 Texture::Format result = instance->getFormat();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_TextureFormat(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_TextureFormat(result));
 
                 return 1;
             }

gameplay/src/lua/lua_VertexFormatElement.cpp

@@ -194,7 +194,7 @@ int lua_VertexFormatElement_usage(lua_State* state)
         VertexFormat::Usage result = instance->usage;
 
         // Push the return value onto the stack.
-        lua_pushstring(state, lua_stringFromEnum_VertexFormatUsage(result).c_str());
+        lua_pushstring(state, lua_stringFromEnum_VertexFormatUsage(result));
 
         return 1;
     }

gameplay/src/lua/lua_VerticalLayout.cpp

@@ -202,7 +202,7 @@ int lua_VerticalLayout_getType(lua_State* state)
                 Layout::Type result = instance->getType();
 
                 // Push the return value onto the stack.
-                lua_pushstring(state, lua_stringFromEnum_LayoutType(result).c_str());
+                lua_pushstring(state, lua_stringFromEnum_LayoutType(result));
 
                 return 1;
             }