Merge pull request #991 from sgrenier/next

Minor fixes

gameplay/res/shaders/colored.frag

@@ -66,7 +66,7 @@ void main()
     gl_FragColor.rgb = getLitPixel();
     
 	#if defined(MODULATE_COLOR)
-    gl_FragColor.a *= u_modulateColor;
+    gl_FragColor *= u_modulateColor;
     #endif
 	#if defined(MODULATE_ALPHA)
     gl_FragColor.a *= u_modulateAlpha;

gameplay/src/Camera.cpp

@@ -354,6 +354,22 @@ void Camera::project(const Rectangle& viewport, const Vector3& position, float*
     }
 }
 
+void Camera::project(const Rectangle& viewport, const Vector3& position, Vector2* out) const
+{
+    GP_ASSERT(out);
+    float x, y;
+    project(viewport, position, &x, &y);
+    out->set(x, y);
+}
+
+void Camera::project(const Rectangle& viewport, const Vector3& position, Vector3* out) const
+{
+    GP_ASSERT(out);
+    float x, y, depth;
+    project(viewport, position, &x, &y, &depth);
+    out->set(x, y, depth);
+}
+
 void Camera::unproject(const Rectangle& viewport, float x, float y, float depth, Vector3* dst) const
 {
     GP_ASSERT(dst);

gameplay/src/Camera.h

@@ -240,9 +240,29 @@ public:
      * @param x The returned viewport x coordinate.
      * @param y The returned viewport y coordinate.
      * @param depth The returned pixel depth (can be NULL).
+     *
+     * @script{ignore}
      */
     void project(const Rectangle& viewport, const Vector3& position, float* x, float* y, float* depth = NULL) const;
 
+    /**
+     * Projects the specified world position into the viewport coordinates.
+     *
+     * @param viewport The viewport rectangle to use.
+     * @param position The world space position.
+     * @param out Populated with the resulting screen-space position.
+     */
+    void project(const Rectangle& viewport, const Vector3& position, Vector2* out) const;
+
+    /**
+     * Projects the specified world position into the viewport coordinates.
+     *
+     * @param viewport The viewport rectangle to use.
+     * @param position The world space position.
+     * @param out Populated with the resulting screen-space position, with the pixel depth in the Z coordinate.
+     */
+    void project(const Rectangle& viewport, const Vector3& position, Vector3* out) const;
+
     /**
      * Converts a viewport-space coordinate to a world-space position for the given depth value.
      *

gameplay/src/Platform.cpp

@@ -42,6 +42,27 @@ bool Platform::mouseEventInternal(Mouse::MouseEvent evt, int x, int y, int wheel
     }
 }
 
+void Platform::gestureSwipeEventInternal(int x, int y, int direction)
+{
+    // TODO: Add support to Form for gestures
+    Game::getInstance()->gestureSwipeEvent(x, y, direction);
+    Game::getInstance()->getScriptController()->gestureSwipeEvent(x, y, direction);
+}
+
+void Platform::gesturePinchEventInternal(int x, int y, float scale)
+{
+    // TODO: Add support to Form for gestures
+    Game::getInstance()->gesturePinchEvent(x, y, scale);
+    Game::getInstance()->getScriptController()->gesturePinchEvent(x, y, scale);
+}
+
+void Platform::gestureTapEventInternal(int x, int y)
+{
+    // TODO: Add support to Form for gestures
+    Game::getInstance()->gestureTapEvent(x, y);
+    Game::getInstance()->getScriptController()->gestureTapEvent(x, y);
+}
+
 void Platform::resizeEventInternal(unsigned int width, unsigned int height)
 {
     // Update the width and height of the game

gameplay/src/Platform.h

@@ -276,14 +276,14 @@ private:
 
 public:
 
-   /**
+    /**
      * Internal method used only from static code in various platform implementation.
      *
      * @script{ignore}
      */
     static void touchEventInternal(Touch::TouchEvent evt, int x, int y, unsigned int contactIndex, bool actuallyMouse = false);
 
-   /**
+    /**
      * Internal method used only from static code in various platform implementation.
      *
      * @script{ignore}
@@ -297,6 +297,27 @@ public:
      */
     static bool mouseEventInternal(Mouse::MouseEvent evt, int x, int y, int wheelDelta);
 
+    /**
+     * Internal method used only from static code in various platform implementation.
+     *
+     * @script{ignore}
+     */
+    static void gestureSwipeEventInternal(int x, int y, int direction);
+
+    /**
+     * Internal method used only from static code in various platform implementation.
+     *
+     * @script{ignore}
+     */
+    static void gesturePinchEventInternal(int x, int y, float scale);
+
+    /**
+     * Internal method used only from static code in various platform implementation.
+     *
+     * @script{ignore}
+     */
+    static void gestureTapEventInternal(int x, int y);
+
     /**
      * Internal method used only from static code in various platform implementation.
      *

gameplay/src/PlatformAndroid.cpp

@@ -744,14 +744,14 @@ static int32_t engine_handle_input(struct android_app* app, AInputEvent* event)
                                 else if (deltaY < 0)
                                     direction = gameplay::Gesture::SWIPE_DIRECTION_UP;
                             }
-                            gameplay::Game::getInstance()->gestureSwipeEvent(x, y, direction);
+                            gameplay::Platform::gestureSwipeEventInternal(x, y, direction);
                             __pointer0.pressed = false;
                             gestureDetected = true;
                         }
                         else if(__gestureEventsProcessed.test(Gesture::GESTURE_TAP) &&
                                gameplay::Game::getInstance()->getAbsoluteTime() - __pointer0.time < GESTURE_TAP_DURATION_MAX)
                         {
-                            gameplay::Game::getInstance()->gestureTapEvent(x, y);
+                            gameplay::Platform::gestureTapEventInternal(x, y);
                             __pointer0.pressed = false;
                             gestureDetected = true;
                         }
@@ -821,14 +821,14 @@ static int32_t engine_handle_input(struct android_app* app, AInputEvent* event)
                             else if (deltaY < 0)
                                 direction |= gameplay::Gesture::SWIPE_DIRECTION_UP;
 
-                            gameplay::Game::getInstance()->gestureSwipeEvent(x, y, direction);
+                            gameplay::Platform::gestureSwipeEventInternal(x, y, direction);
                             __pointer1.pressed = false;
                             gestureDetected = true;
                         }
                         else if(__gestureEventsProcessed.test(Gesture::GESTURE_TAP) &&
                                gameplay::Game::getInstance()->getAbsoluteTime() - __pointer1.time < GESTURE_TAP_DURATION_MAX)
                         {
-                            gameplay::Game::getInstance()->gestureTapEvent(x, y);
+                            gameplay::Platform::gestureTapEventInternal(x, y);
                             __pointer1.pressed = false;
                             gestureDetected = true;
                         }

gameplay/src/PlatformBlackBerry.cpp

@@ -457,7 +457,7 @@ void gesture_callback(gesture_base_t* gesture, mtouch_event_t* event, void* para
                 gesture_swipe_t* swipe = (gesture_swipe_t*)gesture;
                 if (!__gestureSwipeRecognized)
                 {
-                    Game::getInstance()->gestureSwipeEvent(swipe->coords.x, swipe->coords.y, swipe->direction);
+                    Platform::gestureSwipeEventInternal(swipe->coords.x, swipe->coords.y, swipe->direction);
                     __gestureSwipeRecognized = true;
                 }
 
@@ -465,17 +465,17 @@ void gesture_callback(gesture_base_t* gesture, mtouch_event_t* event, void* para
             break;
         }
 
-    case GESTURE_PINCH:
-        {
-            if ( __gestureEventsProcessed.test(Gesture::GESTURE_PINCH) )
-            {
-                gesture_pinch_t* pinch = (gesture_pinch_t*)gesture;
-                float dist_x = (float)pinch->last_distance.x - (float)pinch->distance.x;
-                float dist_y = (float)pinch->last_distance.y - (float)pinch->distance.y;
-                float scale = sqrt( (dist_x * dist_x) + (dist_y * dist_y) );
-                Game::getInstance()->gesturePinchEvent(pinch->centroid.x, pinch->centroid.y, scale);
-            }
-            break;
+    case GESTURE_PINCH:
+        {
+            if ( __gestureEventsProcessed.test(Gesture::GESTURE_PINCH) )
+            {
+                gesture_pinch_t* pinch = (gesture_pinch_t*)gesture;
+                float dist_x = (float)pinch->last_distance.x - (float)pinch->distance.x;
+                float dist_y = (float)pinch->last_distance.y - (float)pinch->distance.y;
+                float scale = sqrt( (dist_x * dist_x) + (dist_y * dist_y) );
+                Game::getInstance()->gesturePinchEvent(pinch->centroid.x, pinch->centroid.y, scale);
+            }
+            break;
         }
 
     case GESTURE_TAP:
@@ -483,7 +483,7 @@ void gesture_callback(gesture_base_t* gesture, mtouch_event_t* event, void* para
             if ( __gestureEventsProcessed.test(Gesture::GESTURE_TAP) )
             {
                 gesture_tap_t* tap = (gesture_tap_t*)gesture;
-                Game::getInstance()->gestureTapEvent(tap->touch_coords.x, tap->touch_coords.y);
+                Platform::gestureTapEventInternal(tap->touch_coords.x, tap->touch_coords.y);
             }
             break;
         }

gameplay/src/PlatformMacOSX.mm

@@ -1569,7 +1569,7 @@ int getUnicode(int key)
     yavg /= [touches count];
     
     [gameLock lock];
-    _game->gesturePinchEvent((int)xavg, (int)yavg, [event magnification]);
+    gameplay::Platform::gesturePinchEventInternal((int)xavg, (int)yavg, [event magnification]);
     [gameLock unlock];
 }
 

gameplay/src/PlatformiOS.mm

@@ -711,14 +711,14 @@ int getUnicode(int key);
 - (void)handleTapGesture:(UITapGestureRecognizer*)sender
 {
     CGPoint location = [sender locationInView:self];
-    game->gestureTapEvent(location.x, location.y);
+    gameplay::Platform::gestureTapEventInternal(location.x, location.y);
 }
 
 - (void)handlePinchGesture:(UIPinchGestureRecognizer*)sender
 {
     CGFloat factor = [sender scale];
     CGPoint location = [sender locationInView:self];
-    game->gesturePinchEvent(location.x, location.y, factor);
+    gameplay::Platform::gesturePinchEventInternal(location.x, location.y, factor);
 }
 
 - (void)handleSwipeGesture:(UISwipeGestureRecognizer*)sender
@@ -740,7 +740,7 @@ int getUnicode(int key);
             gameplayDirection = Gesture::SWIPE_DIRECTION_DOWN;
             break;
     }
-    game->gestureSwipeEvent(location.x, location.y, gameplayDirection);
+    gameplay::Platform::gestureSwipeEventInternal(location.x, location.y, gameplayDirection);
 }
 
 @end

gameplay/src/ScriptController.cpp

@@ -839,6 +839,27 @@ bool ScriptController::mouseEvent(Mouse::MouseEvent evt, int x, int y, int wheel
     return false;
 }
 
+void ScriptController::gestureSwipeEvent(int x, int y, int direction)
+{
+    std::vector<std::string>& list = _callbacks[GESTURE_SWIPE_EVENT];
+    for (size_t i = 0; i < list.size(); ++i)
+        executeFunction<void>(list[i].c_str(), "iii", x, y, direction);
+}
+
+void ScriptController::gesturePinchEvent(int x, int y, float scale)
+{
+    std::vector<std::string>& list = _callbacks[GESTURE_PINCH_EVENT];
+    for (size_t i = 0; i < list.size(); ++i)
+        executeFunction<void>(list[i].c_str(), "iif", x, y, scale);
+}
+
+void ScriptController::gestureTapEvent(int x, int y)
+{
+    std::vector<std::string>& list = _callbacks[GESTURE_TAP_EVENT];
+    for (size_t i = 0; i < list.size(); ++i)
+        executeFunction<void>(list[i].c_str(), "ii", x, y);
+}
+
 void ScriptController::gamepadEvent(Gamepad::GamepadEvent evt, Gamepad* gamepad, unsigned int analogIndex)
 {
     std::vector<std::string>& list = _callbacks[GAMEPAD_EVENT];
@@ -1021,6 +1042,12 @@ ScriptController::ScriptCallback ScriptController::toCallback(const char* name)
         return ScriptController::TOUCH_EVENT;
     else if (strcmp(name, "mouseEvent") == 0)
         return ScriptController::MOUSE_EVENT;
+    else if (strcmp(name, "gestureSwipeEvent") == 0)
+        return ScriptController::GESTURE_SWIPE_EVENT;
+    else if (strcmp(name, "gesturePinchEvent") == 0)
+        return ScriptController::GESTURE_PINCH_EVENT;
+    else if (strcmp(name, "gestureTapEvent") == 0)
+        return ScriptController::GESTURE_TAP_EVENT;
     else if (strcmp(name, "gamepadEvent") == 0)
         return ScriptController::GAMEPAD_EVENT;
     else

gameplay/src/ScriptController.h

@@ -770,6 +770,9 @@ private:
         KEY_EVENT,
         MOUSE_EVENT,
         TOUCH_EVENT,
+        GESTURE_SWIPE_EVENT,
+        GESTURE_PINCH_EVENT,
+        GESTURE_TAP_EVENT,
         GAMEPAD_EVENT,
         CALLBACK_COUNT,
         INVALID_CALLBACK = CALLBACK_COUNT
@@ -867,6 +870,37 @@ private:
      */
     bool mouseEvent(Mouse::MouseEvent evt, int x, int y, int wheelDelta);
 
+    /**
+     * Script callback for Gesture::SWIPE events.
+     *
+     * @param x The x-coordinate of the start of the swipe.
+     * @param y The y-coordinate of the start of the swipe.
+     * @param direction The direction of the swipe
+     *
+     * @see Gesture::SWIPE_DIRECTION_UP
+     * @see Gesture::SWIPE_DIRECTION_DOWN
+     * @see Gesture::SWIPE_DIRECTION_LEFT
+     * @see Gesture::SWIPE_DIRECTION_RIGHT
+     */
+    void gestureSwipeEvent(int x, int y, int direction);
+
+    /**
+     * Script callback for Gesture::PINCH events.
+     *
+     * @param x The centroid x-coordinate of the pinch.
+     * @param y The centroid y-coordinate of the pinch.
+     * @param scale The scale of the pinch.
+     */
+    void gesturePinchEvent(int x, int y, float scale);
+
+    /**
+     * Script callback for Gesture::TAP events.
+     *
+     * @param x The x-coordinate of the tap.
+     * @param y The y-coordinate of the tap.
+     */
+    void gestureTapEvent(int x, int y);
+
     /**
      * Script gamepad callback on gamepad events.
      *

gameplay/src/lua/lua_AIMessageParameterType.cpp

@@ -30,7 +30,6 @@ AIMessage::ParameterType lua_enumFromString_AIMessageParameterType(const char* s
         return AIMessage::BOOLEAN;
     if (strcmp(s, luaEnumString_AIMessageParameterType_STRING) == 0)
         return AIMessage::STRING;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration AIMessage::ParameterType.", s);
     return AIMessage::UNDEFINED;
 }
 
@@ -50,7 +49,6 @@ const char* lua_stringFromEnum_AIMessageParameterType(AIMessage::ParameterType e
         return luaEnumString_AIMessageParameterType_BOOLEAN;
     if (e == AIMessage::STRING)
         return luaEnumString_AIMessageParameterType_STRING;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration AIMessage::ParameterType.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_AnimationClipListenerEventType.cpp

@@ -18,7 +18,6 @@ AnimationClip::Listener::EventType lua_enumFromString_AnimationClipListenerEvent
         return AnimationClip::Listener::END;
     if (strcmp(s, luaEnumString_AnimationClipListenerEventType_TIME) == 0)
         return AnimationClip::Listener::TIME;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration AnimationClip::Listener::EventType.", s);
     return AnimationClip::Listener::BEGIN;
 }
 
@@ -30,7 +29,6 @@ const char* lua_stringFromEnum_AnimationClipListenerEventType(AnimationClip::Lis
         return luaEnumString_AnimationClipListenerEventType_END;
     if (e == AnimationClip::Listener::TIME)
         return luaEnumString_AnimationClipListenerEventType_TIME;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration AnimationClip::Listener::EventType.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_AudioSourceState.cpp

@@ -21,7 +21,6 @@ AudioSource::State lua_enumFromString_AudioSourceState(const char* s)
         return AudioSource::PAUSED;
     if (strcmp(s, luaEnumString_AudioSourceState_STOPPED) == 0)
         return AudioSource::STOPPED;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration AudioSource::State.", s);
     return AudioSource::INITIAL;
 }
 
@@ -35,7 +34,6 @@ const char* lua_stringFromEnum_AudioSourceState(AudioSource::State e)
         return luaEnumString_AudioSourceState_PAUSED;
     if (e == AudioSource::STOPPED)
         return luaEnumString_AudioSourceState_STOPPED;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration AudioSource::State.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_Camera.cpp

@@ -797,89 +797,71 @@ int lua_Camera_project(lua_State* state)
     // Attempt to match the parameters to a valid binding.
     switch (paramCount)
     {
-        case 5:
+        case 4:
         {
-            if ((lua_type(state, 1) == LUA_TUSERDATA) &&
-                (lua_type(state, 2) == LUA_TUSERDATA || lua_type(state, 2) == LUA_TNIL) &&
-                (lua_type(state, 3) == LUA_TUSERDATA || lua_type(state, 3) == LUA_TNIL) &&
-                (lua_type(state, 4) == LUA_TTABLE || lua_type(state, 4) == LUA_TLIGHTUSERDATA) &&
-                (lua_type(state, 5) == LUA_TTABLE || lua_type(state, 5) == LUA_TLIGHTUSERDATA))
+            do
             {
-                // Get parameter 1 off the stack.
-                bool param1Valid;
-                gameplay::ScriptUtil::LuaArray<Rectangle> param1 = gameplay::ScriptUtil::getObjectPointer<Rectangle>(2, "Rectangle", true, &param1Valid);
-                if (!param1Valid)
-                {
-                    lua_pushstring(state, "Failed to convert parameter 1 to type 'Rectangle'.");
-                    lua_error(state);
-                }
-
-                // Get parameter 2 off the stack.
-                bool param2Valid;
-                gameplay::ScriptUtil::LuaArray<Vector3> param2 = gameplay::ScriptUtil::getObjectPointer<Vector3>(3, "Vector3", true, &param2Valid);
-                if (!param2Valid)
+                if ((lua_type(state, 1) == LUA_TUSERDATA) &&
+                    (lua_type(state, 2) == LUA_TUSERDATA || lua_type(state, 2) == LUA_TNIL) &&
+                    (lua_type(state, 3) == LUA_TUSERDATA || lua_type(state, 3) == LUA_TNIL) &&
+                    (lua_type(state, 4) == LUA_TUSERDATA || lua_type(state, 4) == LUA_TTABLE || lua_type(state, 4) == LUA_TNIL))
                 {
-                    lua_pushstring(state, "Failed to convert parameter 2 to type 'Vector3'.");
-                    lua_error(state);
+                    // Get parameter 1 off the stack.
+                    bool param1Valid;
+                    gameplay::ScriptUtil::LuaArray<Rectangle> param1 = gameplay::ScriptUtil::getObjectPointer<Rectangle>(2, "Rectangle", true, &param1Valid);
+                    if (!param1Valid)
+                        break;
+
+                    // Get parameter 2 off the stack.
+                    bool param2Valid;
+                    gameplay::ScriptUtil::LuaArray<Vector3> param2 = gameplay::ScriptUtil::getObjectPointer<Vector3>(3, "Vector3", true, &param2Valid);
+                    if (!param2Valid)
+                        break;
+
+                    // Get parameter 3 off the stack.
+                    bool param3Valid;
+                    gameplay::ScriptUtil::LuaArray<Vector2> param3 = gameplay::ScriptUtil::getObjectPointer<Vector2>(4, "Vector2", false, &param3Valid);
+                    if (!param3Valid)
+                        break;
+
+                    Camera* instance = getInstance(state);
+                    instance->project(*param1, *param2, param3);
+                    
+                    return 0;
                 }
+            } while (0);
 
-                // Get parameter 3 off the stack.
-                gameplay::ScriptUtil::LuaArray<float> param3 = gameplay::ScriptUtil::getFloatPointer(4);
-
-                // Get parameter 4 off the stack.
-                gameplay::ScriptUtil::LuaArray<float> param4 = gameplay::ScriptUtil::getFloatPointer(5);
-
-                Camera* instance = getInstance(state);
-                instance->project(*param1, *param2, param3, param4);
-                
-                return 0;
-            }
-
-            lua_pushstring(state, "lua_Camera_project - Failed to match the given parameters to a valid function signature.");
-            lua_error(state);
-            break;
-        }
-        case 6:
-        {
-            if ((lua_type(state, 1) == LUA_TUSERDATA) &&
-                (lua_type(state, 2) == LUA_TUSERDATA || lua_type(state, 2) == LUA_TNIL) &&
-                (lua_type(state, 3) == LUA_TUSERDATA || lua_type(state, 3) == LUA_TNIL) &&
-                (lua_type(state, 4) == LUA_TTABLE || lua_type(state, 4) == LUA_TLIGHTUSERDATA) &&
-                (lua_type(state, 5) == LUA_TTABLE || lua_type(state, 5) == LUA_TLIGHTUSERDATA) &&
-                (lua_type(state, 6) == LUA_TTABLE || lua_type(state, 6) == LUA_TLIGHTUSERDATA))
+            do
             {
-                // Get parameter 1 off the stack.
-                bool param1Valid;
-                gameplay::ScriptUtil::LuaArray<Rectangle> param1 = gameplay::ScriptUtil::getObjectPointer<Rectangle>(2, "Rectangle", true, &param1Valid);
-                if (!param1Valid)
+                if ((lua_type(state, 1) == LUA_TUSERDATA) &&
+                    (lua_type(state, 2) == LUA_TUSERDATA || lua_type(state, 2) == LUA_TNIL) &&
+                    (lua_type(state, 3) == LUA_TUSERDATA || lua_type(state, 3) == LUA_TNIL) &&
+                    (lua_type(state, 4) == LUA_TUSERDATA || lua_type(state, 4) == LUA_TTABLE || lua_type(state, 4) == LUA_TNIL))
                 {
-                    lua_pushstring(state, "Failed to convert parameter 1 to type 'Rectangle'.");
-                    lua_error(state);
+                    // Get parameter 1 off the stack.
+                    bool param1Valid;
+                    gameplay::ScriptUtil::LuaArray<Rectangle> param1 = gameplay::ScriptUtil::getObjectPointer<Rectangle>(2, "Rectangle", true, &param1Valid);
+                    if (!param1Valid)
+                        break;
+
+                    // Get parameter 2 off the stack.
+                    bool param2Valid;
+                    gameplay::ScriptUtil::LuaArray<Vector3> param2 = gameplay::ScriptUtil::getObjectPointer<Vector3>(3, "Vector3", true, &param2Valid);
+                    if (!param2Valid)
+                        break;
+
+                    // Get parameter 3 off the stack.
+                    bool param3Valid;
+                    gameplay::ScriptUtil::LuaArray<Vector3> param3 = gameplay::ScriptUtil::getObjectPointer<Vector3>(4, "Vector3", false, &param3Valid);
+                    if (!param3Valid)
+                        break;
+
+                    Camera* instance = getInstance(state);
+                    instance->project(*param1, *param2, param3);
+                    
+                    return 0;
                 }
-
-                // Get parameter 2 off the stack.
-                bool param2Valid;
-                gameplay::ScriptUtil::LuaArray<Vector3> param2 = gameplay::ScriptUtil::getObjectPointer<Vector3>(3, "Vector3", true, &param2Valid);
-                if (!param2Valid)
-                {
-                    lua_pushstring(state, "Failed to convert parameter 2 to type 'Vector3'.");
-                    lua_error(state);
-                }
-
-                // Get parameter 3 off the stack.
-                gameplay::ScriptUtil::LuaArray<float> param3 = gameplay::ScriptUtil::getFloatPointer(4);
-
-                // Get parameter 4 off the stack.
-                gameplay::ScriptUtil::LuaArray<float> param4 = gameplay::ScriptUtil::getFloatPointer(5);
-
-                // Get parameter 5 off the stack.
-                gameplay::ScriptUtil::LuaArray<float> param5 = gameplay::ScriptUtil::getFloatPointer(6);
-
-                Camera* instance = getInstance(state);
-                instance->project(*param1, *param2, param3, param4, param5);
-                
-                return 0;
-            }
+            } while (0);
 
             lua_pushstring(state, "lua_Camera_project - Failed to match the given parameters to a valid function signature.");
             lua_error(state);
@@ -887,7 +869,7 @@ int lua_Camera_project(lua_State* state)
         }
         default:
         {
-            lua_pushstring(state, "Invalid number of parameters (expected 5 or 6).");
+            lua_pushstring(state, "Invalid number of parameters (expected 4).");
             lua_error(state);
             break;
         }

gameplay/src/lua/lua_CameraType.cpp

@@ -15,7 +15,6 @@ Camera::Type lua_enumFromString_CameraType(const char* s)
         return Camera::PERSPECTIVE;
     if (strcmp(s, luaEnumString_CameraType_ORTHOGRAPHIC) == 0)
         return Camera::ORTHOGRAPHIC;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration Camera::Type.", s);
     return Camera::PERSPECTIVE;
 }
 
@@ -25,7 +24,6 @@ const char* lua_stringFromEnum_CameraType(Camera::Type e)
         return luaEnumString_CameraType_PERSPECTIVE;
     if (e == Camera::ORTHOGRAPHIC)
         return luaEnumString_CameraType_ORTHOGRAPHIC;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Camera::Type.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_ContainerScroll.cpp

@@ -21,7 +21,6 @@ Container::Scroll lua_enumFromString_ContainerScroll(const char* s)
         return Container::SCROLL_VERTICAL;
     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;
 }
 
@@ -35,7 +34,6 @@ const char* lua_stringFromEnum_ContainerScroll(Container::Scroll e)
         return luaEnumString_ContainerScroll_SCROLL_VERTICAL;
     if (e == Container::SCROLL_BOTH)
         return luaEnumString_ContainerScroll_SCROLL_BOTH;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Container::Scroll.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_ControlAlignment.cpp

@@ -54,7 +54,6 @@ Control::Alignment lua_enumFromString_ControlAlignment(const char* s)
         return Control::ALIGN_VCENTER_RIGHT;
     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;
 }
 
@@ -90,7 +89,6 @@ const char* lua_stringFromEnum_ControlAlignment(Control::Alignment e)
         return luaEnumString_ControlAlignment_ALIGN_VCENTER_RIGHT;
     if (e == Control::ALIGN_BOTTOM_RIGHT)
         return luaEnumString_ControlAlignment_ALIGN_BOTTOM_RIGHT;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Control::Alignment.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_CurveInterpolationType.cpp

@@ -150,7 +150,6 @@ Curve::InterpolationType lua_enumFromString_CurveInterpolationType(const char* s
         return Curve::BOUNCE_IN_OUT;
     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;
 }
 
@@ -250,7 +249,6 @@ const char* lua_stringFromEnum_CurveInterpolationType(Curve::InterpolationType e
         return luaEnumString_CurveInterpolationType_BOUNCE_IN_OUT;
     if (e == Curve::BOUNCE_OUT_IN)
         return luaEnumString_CurveInterpolationType_BOUNCE_OUT_IN;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Curve::InterpolationType.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_DepthStencilTargetFormat.cpp

@@ -15,7 +15,6 @@ DepthStencilTarget::Format lua_enumFromString_DepthStencilTargetFormat(const cha
         return DepthStencilTarget::DEPTH;
     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;
 }
 
@@ -25,7 +24,6 @@ const char* lua_stringFromEnum_DepthStencilTargetFormat(DepthStencilTarget::Form
         return luaEnumString_DepthStencilTargetFormat_DEPTH;
     if (e == DepthStencilTarget::DEPTH_STENCIL)
         return luaEnumString_DepthStencilTargetFormat_DEPTH_STENCIL;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration DepthStencilTarget::Format.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_FontJustify.cpp

@@ -54,7 +54,6 @@ Font::Justify lua_enumFromString_FontJustify(const char* s)
         return Font::ALIGN_VCENTER_RIGHT;
     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;
 }
 
@@ -90,7 +89,6 @@ const char* lua_stringFromEnum_FontJustify(Font::Justify e)
         return luaEnumString_FontJustify_ALIGN_VCENTER_RIGHT;
     if (e == Font::ALIGN_BOTTOM_RIGHT)
         return luaEnumString_FontJustify_ALIGN_BOTTOM_RIGHT;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Font::Justify.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_FontStyle.cpp

@@ -21,7 +21,6 @@ Font::Style lua_enumFromString_FontStyle(const char* s)
         return Font::ITALIC;
     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;
 }
 
@@ -35,7 +34,6 @@ const char* lua_stringFromEnum_FontStyle(Font::Style e)
         return luaEnumString_FontStyle_ITALIC;
     if (e == Font::BOLD_ITALIC)
         return luaEnumString_FontStyle_BOLD_ITALIC;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Font::Style.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_GameClearFlags.cpp

@@ -30,7 +30,6 @@ Game::ClearFlags lua_enumFromString_GameClearFlags(const char* s)
         return Game::CLEAR_DEPTH_STENCIL;
     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;
 }
 
@@ -50,7 +49,6 @@ const char* lua_stringFromEnum_GameClearFlags(Game::ClearFlags e)
         return luaEnumString_GameClearFlags_CLEAR_DEPTH_STENCIL;
     if (e == Game::CLEAR_COLOR_DEPTH_STENCIL)
         return luaEnumString_GameClearFlags_CLEAR_COLOR_DEPTH_STENCIL;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Game::ClearFlags.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_GameState.cpp

@@ -18,7 +18,6 @@ Game::State lua_enumFromString_GameState(const char* s)
         return Game::RUNNING;
     if (strcmp(s, luaEnumString_GameState_PAUSED) == 0)
         return Game::PAUSED;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration Game::State.", s);
     return Game::UNINITIALIZED;
 }
 
@@ -30,7 +29,6 @@ const char* lua_stringFromEnum_GameState(Game::State e)
         return luaEnumString_GameState_RUNNING;
     if (e == Game::PAUSED)
         return luaEnumString_GameState_PAUSED;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Game::State.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_GamepadButtonMapping.cpp

@@ -69,7 +69,6 @@ Gamepad::ButtonMapping lua_enumFromString_GamepadButtonMapping(const char* s)
         return Gamepad::BUTTON_LEFT;
     if (strcmp(s, luaEnumString_GamepadButtonMapping_BUTTON_RIGHT) == 0)
         return Gamepad::BUTTON_RIGHT;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration Gamepad::ButtonMapping.", s);
     return Gamepad::BUTTON_A;
 }
 
@@ -115,7 +114,6 @@ const char* lua_stringFromEnum_GamepadButtonMapping(Gamepad::ButtonMapping e)
         return luaEnumString_GamepadButtonMapping_BUTTON_LEFT;
     if (e == Gamepad::BUTTON_RIGHT)
         return luaEnumString_GamepadButtonMapping_BUTTON_RIGHT;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Gamepad::ButtonMapping.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_GamepadGamepadEvent.cpp

@@ -24,7 +24,6 @@ Gamepad::GamepadEvent lua_enumFromString_GamepadGamepadEvent(const char* s)
         return Gamepad::JOYSTICK_EVENT;
     if (strcmp(s, luaEnumString_GamepadGamepadEvent_TRIGGER_EVENT) == 0)
         return Gamepad::TRIGGER_EVENT;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration Gamepad::GamepadEvent.", s);
     return Gamepad::CONNECTED_EVENT;
 }
 
@@ -40,7 +39,6 @@ const char* lua_stringFromEnum_GamepadGamepadEvent(Gamepad::GamepadEvent e)
         return luaEnumString_GamepadGamepadEvent_JOYSTICK_EVENT;
     if (e == Gamepad::TRIGGER_EVENT)
         return luaEnumString_GamepadGamepadEvent_TRIGGER_EVENT;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Gamepad::GamepadEvent.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_GestureGestureEvent.cpp

@@ -21,7 +21,6 @@ Gesture::GestureEvent lua_enumFromString_GestureGestureEvent(const char* s)
         return Gesture::GESTURE_PINCH;
     if (strcmp(s, luaEnumString_GestureGestureEvent_GESTURE_ANY_SUPPORTED) == 0)
         return Gesture::GESTURE_ANY_SUPPORTED;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration Gesture::GestureEvent.", s);
     return Gesture::GESTURE_TAP;
 }
 
@@ -35,7 +34,6 @@ const char* lua_stringFromEnum_GestureGestureEvent(Gesture::GestureEvent e)
         return luaEnumString_GestureGestureEvent_GESTURE_PINCH;
     if (e == Gesture::GESTURE_ANY_SUPPORTED)
         return luaEnumString_GestureGestureEvent_GESTURE_ANY_SUPPORTED;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Gesture::GestureEvent.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_ImageFormat.cpp

@@ -15,7 +15,6 @@ Image::Format lua_enumFromString_ImageFormat(const char* s)
         return Image::RGB;
     if (strcmp(s, luaEnumString_ImageFormat_RGBA) == 0)
         return Image::RGBA;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration Image::Format.", s);
     return Image::RGB;
 }
 
@@ -25,7 +24,6 @@ const char* lua_stringFromEnum_ImageFormat(Image::Format e)
         return luaEnumString_ImageFormat_RGB;
     if (e == Image::RGBA)
         return luaEnumString_ImageFormat_RGBA;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Image::Format.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_KeyboardKey.cpp

@@ -477,7 +477,6 @@ Keyboard::Key lua_enumFromString_KeyboardKey(const char* s)
         return Keyboard::KEY_MIDDLE_DOT;
     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;
 }
 
@@ -795,7 +794,6 @@ const char* lua_stringFromEnum_KeyboardKey(Keyboard::Key e)
         return luaEnumString_KeyboardKey_KEY_MIDDLE_DOT;
     if (e == Keyboard::KEY_SEARCH)
         return luaEnumString_KeyboardKey_KEY_SEARCH;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Keyboard::Key.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_KeyboardKeyEvent.cpp

@@ -18,7 +18,6 @@ Keyboard::KeyEvent lua_enumFromString_KeyboardKeyEvent(const char* s)
         return Keyboard::KEY_RELEASE;
     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;
 }
 
@@ -30,7 +29,6 @@ const char* lua_stringFromEnum_KeyboardKeyEvent(Keyboard::KeyEvent e)
         return luaEnumString_KeyboardKeyEvent_KEY_RELEASE;
     if (e == Keyboard::KEY_CHAR)
         return luaEnumString_KeyboardKeyEvent_KEY_CHAR;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Keyboard::KeyEvent.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_LayoutType.cpp

@@ -18,7 +18,6 @@ Layout::Type lua_enumFromString_LayoutType(const char* s)
         return Layout::LAYOUT_VERTICAL;
     if (strcmp(s, luaEnumString_LayoutType_LAYOUT_ABSOLUTE) == 0)
         return Layout::LAYOUT_ABSOLUTE;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration Layout::Type.", s);
     return Layout::LAYOUT_FLOW;
 }
 
@@ -30,7 +29,6 @@ const char* lua_stringFromEnum_LayoutType(Layout::Type e)
         return luaEnumString_LayoutType_LAYOUT_VERTICAL;
     if (e == Layout::LAYOUT_ABSOLUTE)
         return luaEnumString_LayoutType_LAYOUT_ABSOLUTE;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Layout::Type.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_LightType.cpp

@@ -18,7 +18,6 @@ Light::Type lua_enumFromString_LightType(const char* s)
         return Light::POINT;
     if (strcmp(s, luaEnumString_LightType_SPOT) == 0)
         return Light::SPOT;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration Light::Type.", s);
     return Light::DIRECTIONAL;
 }
 
@@ -30,7 +29,6 @@ const char* lua_stringFromEnum_LightType(Light::Type e)
         return luaEnumString_LightType_POINT;
     if (e == Light::SPOT)
         return luaEnumString_LightType_SPOT;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Light::Type.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_LoggerLevel.cpp

@@ -18,7 +18,6 @@ Logger::Level lua_enumFromString_LoggerLevel(const char* s)
         return Logger::LEVEL_WARN;
     if (strcmp(s, luaEnumString_LoggerLevel_LEVEL_ERROR) == 0)
         return Logger::LEVEL_ERROR;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration Logger::Level.", s);
     return Logger::LEVEL_INFO;
 }
 
@@ -30,7 +29,6 @@ const char* lua_stringFromEnum_LoggerLevel(Logger::Level e)
         return luaEnumString_LoggerLevel_LEVEL_WARN;
     if (e == Logger::LEVEL_ERROR)
         return luaEnumString_LoggerLevel_LEVEL_ERROR;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Logger::Level.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_MaterialParameter.cpp

@@ -1984,7 +1984,7 @@ int lua_MaterialParameter_setVector3Array(lua_State* state)
 
                 MaterialParameter* instance = getInstance(state);
                 instance->setVector3Array(param1, param2);
-
+                
                 return 0;
             }
 
@@ -2016,7 +2016,7 @@ int lua_MaterialParameter_setVector3Array(lua_State* state)
 
                 MaterialParameter* instance = getInstance(state);
                 instance->setVector3Array(param1, param2, param3);
-
+                
                 return 0;
             }
 

gameplay/src/lua/lua_MeshIndexFormat.cpp

@@ -18,7 +18,6 @@ Mesh::IndexFormat lua_enumFromString_MeshIndexFormat(const char* s)
         return Mesh::INDEX16;
     if (strcmp(s, luaEnumString_MeshIndexFormat_INDEX32) == 0)
         return Mesh::INDEX32;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration Mesh::IndexFormat.", s);
     return Mesh::INDEX8;
 }
 
@@ -30,7 +29,6 @@ const char* lua_stringFromEnum_MeshIndexFormat(Mesh::IndexFormat e)
         return luaEnumString_MeshIndexFormat_INDEX16;
     if (e == Mesh::INDEX32)
         return luaEnumString_MeshIndexFormat_INDEX32;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Mesh::IndexFormat.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_MeshPrimitiveType.cpp

@@ -24,7 +24,6 @@ Mesh::PrimitiveType lua_enumFromString_MeshPrimitiveType(const char* s)
         return Mesh::LINE_STRIP;
     if (strcmp(s, luaEnumString_MeshPrimitiveType_POINTS) == 0)
         return Mesh::POINTS;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration Mesh::PrimitiveType.", s);
     return Mesh::TRIANGLES;
 }
 
@@ -40,7 +39,6 @@ const char* lua_stringFromEnum_MeshPrimitiveType(Mesh::PrimitiveType e)
         return luaEnumString_MeshPrimitiveType_LINE_STRIP;
     if (e == Mesh::POINTS)
         return luaEnumString_MeshPrimitiveType_POINTS;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Mesh::PrimitiveType.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_MouseMouseEvent.cpp

@@ -33,7 +33,6 @@ Mouse::MouseEvent lua_enumFromString_MouseMouseEvent(const char* s)
         return Mouse::MOUSE_MOVE;
     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;
 }
 
@@ -55,7 +54,6 @@ const char* lua_stringFromEnum_MouseMouseEvent(Mouse::MouseEvent e)
         return luaEnumString_MouseMouseEvent_MOUSE_MOVE;
     if (e == Mouse::MOUSE_WHEEL)
         return luaEnumString_MouseMouseEvent_MOUSE_WHEEL;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Mouse::MouseEvent.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_NodeType.cpp

@@ -15,7 +15,6 @@ Node::Type lua_enumFromString_NodeType(const char* s)
         return Node::NODE;
     if (strcmp(s, luaEnumString_NodeType_JOINT) == 0)
         return Node::JOINT;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration Node::Type.", s);
     return Node::NODE;
 }
 
@@ -25,7 +24,6 @@ const char* lua_stringFromEnum_NodeType(Node::Type e)
         return luaEnumString_NodeType_NODE;
     if (e == Node::JOINT)
         return luaEnumString_NodeType_JOINT;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Node::Type.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_ParticleEmitterTextureBlending.cpp

@@ -21,7 +21,6 @@ ParticleEmitter::TextureBlending lua_enumFromString_ParticleEmitterTextureBlendi
         return ParticleEmitter::BLEND_ADDITIVE;
     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;
 }
 
@@ -35,7 +34,6 @@ const char* lua_stringFromEnum_ParticleEmitterTextureBlending(ParticleEmitter::T
         return luaEnumString_ParticleEmitterTextureBlending_BLEND_ADDITIVE;
     if (e == ParticleEmitter::BLEND_MULTIPLIED)
         return luaEnumString_ParticleEmitterTextureBlending_BLEND_MULTIPLIED;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration ParticleEmitter::TextureBlending.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_PhysicsCollisionObjectCollisionListenerEventType.cpp

@@ -15,7 +15,6 @@ PhysicsCollisionObject::CollisionListener::EventType lua_enumFromString_PhysicsC
         return PhysicsCollisionObject::CollisionListener::COLLIDING;
     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;
 }
 
@@ -25,7 +24,6 @@ const char* lua_stringFromEnum_PhysicsCollisionObjectCollisionListenerEventType(
         return luaEnumString_PhysicsCollisionObjectCollisionListenerEventType_COLLIDING;
     if (e == PhysicsCollisionObject::CollisionListener::NOT_COLLIDING)
         return luaEnumString_PhysicsCollisionObjectCollisionListenerEventType_NOT_COLLIDING;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration PhysicsCollisionObject::CollisionListener::EventType.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_PhysicsCollisionObjectType.cpp

@@ -27,7 +27,6 @@ PhysicsCollisionObject::Type lua_enumFromString_PhysicsCollisionObjectType(const
         return PhysicsCollisionObject::VEHICLE_WHEEL;
     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;
 }
 
@@ -45,7 +44,6 @@ const char* lua_stringFromEnum_PhysicsCollisionObjectType(PhysicsCollisionObject
         return luaEnumString_PhysicsCollisionObjectType_VEHICLE_WHEEL;
     if (e == PhysicsCollisionObject::NONE)
         return luaEnumString_PhysicsCollisionObjectType_NONE;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration PhysicsCollisionObject::Type.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_PhysicsCollisionShapeType.cpp

@@ -27,7 +27,6 @@ PhysicsCollisionShape::Type lua_enumFromString_PhysicsCollisionShapeType(const c
         return PhysicsCollisionShape::SHAPE_MESH;
     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_NONE;
 }
 
@@ -45,7 +44,6 @@ const char* lua_stringFromEnum_PhysicsCollisionShapeType(PhysicsCollisionShape::
         return luaEnumString_PhysicsCollisionShapeType_SHAPE_MESH;
     if (e == PhysicsCollisionShape::SHAPE_HEIGHTFIELD)
         return luaEnumString_PhysicsCollisionShapeType_SHAPE_HEIGHTFIELD;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration PhysicsCollisionShape::Type.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_PhysicsControllerListenerEventType.cpp

@@ -15,7 +15,6 @@ PhysicsController::Listener::EventType lua_enumFromString_PhysicsControllerListe
         return PhysicsController::Listener::ACTIVATED;
     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;
 }
 
@@ -25,7 +24,6 @@ const char* lua_stringFromEnum_PhysicsControllerListenerEventType(PhysicsControl
         return luaEnumString_PhysicsControllerListenerEventType_ACTIVATED;
     if (e == PhysicsController::Listener::DEACTIVATED)
         return luaEnumString_PhysicsControllerListenerEventType_DEACTIVATED;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration PhysicsController::Listener::EventType.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_PropertiesType.cpp

@@ -30,7 +30,6 @@ Properties::Type lua_enumFromString_PropertiesType(const char* s)
         return Properties::VECTOR4;
     if (strcmp(s, luaEnumString_PropertiesType_MATRIX) == 0)
         return Properties::MATRIX;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration Properties::Type.", s);
     return Properties::NONE;
 }
 
@@ -50,7 +49,6 @@ const char* lua_stringFromEnum_PropertiesType(Properties::Type e)
         return luaEnumString_PropertiesType_VECTOR4;
     if (e == Properties::MATRIX)
         return luaEnumString_PropertiesType_MATRIX;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Properties::Type.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_RenderStateAutoBinding.cpp

@@ -54,7 +54,6 @@ RenderState::AutoBinding lua_enumFromString_RenderStateAutoBinding(const char* s
         return RenderState::SCENE_LIGHT_COLOR;
     if (strcmp(s, luaEnumString_RenderStateAutoBinding_SCENE_LIGHT_DIRECTION) == 0)
         return RenderState::SCENE_LIGHT_DIRECTION;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration RenderState::AutoBinding.", s);
     return RenderState::NONE;
 }
 
@@ -90,7 +89,6 @@ const char* lua_stringFromEnum_RenderStateAutoBinding(RenderState::AutoBinding e
         return luaEnumString_RenderStateAutoBinding_SCENE_LIGHT_COLOR;
     if (e == RenderState::SCENE_LIGHT_DIRECTION)
         return luaEnumString_RenderStateAutoBinding_SCENE_LIGHT_DIRECTION;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration RenderState::AutoBinding.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_RenderStateBlend.cpp

@@ -48,7 +48,6 @@ RenderState::Blend lua_enumFromString_RenderStateBlend(const char* s)
         return RenderState::BLEND_ONE_MINUS_CONSTANT_ALPHA;
     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;
 }
 
@@ -80,7 +79,6 @@ const char* lua_stringFromEnum_RenderStateBlend(RenderState::Blend e)
         return luaEnumString_RenderStateBlend_BLEND_ONE_MINUS_CONSTANT_ALPHA;
     if (e == RenderState::BLEND_SRC_ALPHA_SATURATE)
         return luaEnumString_RenderStateBlend_BLEND_SRC_ALPHA_SATURATE;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration RenderState::Blend.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_RenderStateDepthFunction.cpp

@@ -1,63 +1,61 @@
-#include "Base.h"
-#include "lua_RenderStateDepthFunction.h"
-
-namespace gameplay
-{
-
-static const char* enumStringEmpty = "";
-
-static const char* luaEnumString_RenderStateDepthFunction_DEPTH_NEVER = "DEPTH_NEVER";
-static const char* luaEnumString_RenderStateDepthFunction_DEPTH_LESS = "DEPTH_LESS";
-static const char* luaEnumString_RenderStateDepthFunction_DEPTH_EQUAL = "DEPTH_EQUAL";
-static const char* luaEnumString_RenderStateDepthFunction_DEPTH_LEQUAL = "DEPTH_LEQUAL";
-static const char* luaEnumString_RenderStateDepthFunction_DEPTH_GREATER = "DEPTH_GREATER";
-static const char* luaEnumString_RenderStateDepthFunction_DEPTH_NOTEQUAL = "DEPTH_NOTEQUAL";
-static const char* luaEnumString_RenderStateDepthFunction_DEPTH_GEQUAL = "DEPTH_GEQUAL";
-static const char* luaEnumString_RenderStateDepthFunction_DEPTH_ALWAYS = "DEPTH_ALWAYS";
-
-RenderState::DepthFunction lua_enumFromString_RenderStateDepthFunction(const char* s)
-{
-    if (strcmp(s, luaEnumString_RenderStateDepthFunction_DEPTH_NEVER) == 0)
-        return RenderState::DEPTH_NEVER;
-    if (strcmp(s, luaEnumString_RenderStateDepthFunction_DEPTH_LESS) == 0)
-        return RenderState::DEPTH_LESS;
-    if (strcmp(s, luaEnumString_RenderStateDepthFunction_DEPTH_EQUAL) == 0)
-        return RenderState::DEPTH_EQUAL;
-    if (strcmp(s, luaEnumString_RenderStateDepthFunction_DEPTH_LEQUAL) == 0)
-        return RenderState::DEPTH_LEQUAL;
-    if (strcmp(s, luaEnumString_RenderStateDepthFunction_DEPTH_GREATER) == 0)
-        return RenderState::DEPTH_GREATER;
-    if (strcmp(s, luaEnumString_RenderStateDepthFunction_DEPTH_NOTEQUAL) == 0)
-        return RenderState::DEPTH_NOTEQUAL;
-    if (strcmp(s, luaEnumString_RenderStateDepthFunction_DEPTH_GEQUAL) == 0)
-        return RenderState::DEPTH_GEQUAL;
-    if (strcmp(s, luaEnumString_RenderStateDepthFunction_DEPTH_ALWAYS) == 0)
-        return RenderState::DEPTH_ALWAYS;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration RenderState::DepthFunction.", s);
-    return RenderState::DEPTH_NEVER;
-}
-
-const char* lua_stringFromEnum_RenderStateDepthFunction(RenderState::DepthFunction e)
-{
-    if (e == RenderState::DEPTH_NEVER)
-        return luaEnumString_RenderStateDepthFunction_DEPTH_NEVER;
-    if (e == RenderState::DEPTH_LESS)
-        return luaEnumString_RenderStateDepthFunction_DEPTH_LESS;
-    if (e == RenderState::DEPTH_EQUAL)
-        return luaEnumString_RenderStateDepthFunction_DEPTH_EQUAL;
-    if (e == RenderState::DEPTH_LEQUAL)
-        return luaEnumString_RenderStateDepthFunction_DEPTH_LEQUAL;
-    if (e == RenderState::DEPTH_GREATER)
-        return luaEnumString_RenderStateDepthFunction_DEPTH_GREATER;
-    if (e == RenderState::DEPTH_NOTEQUAL)
-        return luaEnumString_RenderStateDepthFunction_DEPTH_NOTEQUAL;
-    if (e == RenderState::DEPTH_GEQUAL)
-        return luaEnumString_RenderStateDepthFunction_DEPTH_GEQUAL;
-    if (e == RenderState::DEPTH_ALWAYS)
-        return luaEnumString_RenderStateDepthFunction_DEPTH_ALWAYS;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration RenderState::DepthFunction.", e);
-    return enumStringEmpty;
-}
-
-}
-
+#include "Base.h"
+#include "lua_RenderStateDepthFunction.h"
+
+namespace gameplay
+{
+
+static const char* enumStringEmpty = "";
+
+static const char* luaEnumString_RenderStateDepthFunction_DEPTH_NEVER = "DEPTH_NEVER";
+static const char* luaEnumString_RenderStateDepthFunction_DEPTH_LESS = "DEPTH_LESS";
+static const char* luaEnumString_RenderStateDepthFunction_DEPTH_EQUAL = "DEPTH_EQUAL";
+static const char* luaEnumString_RenderStateDepthFunction_DEPTH_LEQUAL = "DEPTH_LEQUAL";
+static const char* luaEnumString_RenderStateDepthFunction_DEPTH_GREATER = "DEPTH_GREATER";
+static const char* luaEnumString_RenderStateDepthFunction_DEPTH_NOTEQUAL = "DEPTH_NOTEQUAL";
+static const char* luaEnumString_RenderStateDepthFunction_DEPTH_GEQUAL = "DEPTH_GEQUAL";
+static const char* luaEnumString_RenderStateDepthFunction_DEPTH_ALWAYS = "DEPTH_ALWAYS";
+
+RenderState::DepthFunction lua_enumFromString_RenderStateDepthFunction(const char* s)
+{
+    if (strcmp(s, luaEnumString_RenderStateDepthFunction_DEPTH_NEVER) == 0)
+        return RenderState::DEPTH_NEVER;
+    if (strcmp(s, luaEnumString_RenderStateDepthFunction_DEPTH_LESS) == 0)
+        return RenderState::DEPTH_LESS;
+    if (strcmp(s, luaEnumString_RenderStateDepthFunction_DEPTH_EQUAL) == 0)
+        return RenderState::DEPTH_EQUAL;
+    if (strcmp(s, luaEnumString_RenderStateDepthFunction_DEPTH_LEQUAL) == 0)
+        return RenderState::DEPTH_LEQUAL;
+    if (strcmp(s, luaEnumString_RenderStateDepthFunction_DEPTH_GREATER) == 0)
+        return RenderState::DEPTH_GREATER;
+    if (strcmp(s, luaEnumString_RenderStateDepthFunction_DEPTH_NOTEQUAL) == 0)
+        return RenderState::DEPTH_NOTEQUAL;
+    if (strcmp(s, luaEnumString_RenderStateDepthFunction_DEPTH_GEQUAL) == 0)
+        return RenderState::DEPTH_GEQUAL;
+    if (strcmp(s, luaEnumString_RenderStateDepthFunction_DEPTH_ALWAYS) == 0)
+        return RenderState::DEPTH_ALWAYS;
+    return RenderState::DEPTH_NEVER;
+}
+
+const char* lua_stringFromEnum_RenderStateDepthFunction(RenderState::DepthFunction e)
+{
+    if (e == RenderState::DEPTH_NEVER)
+        return luaEnumString_RenderStateDepthFunction_DEPTH_NEVER;
+    if (e == RenderState::DEPTH_LESS)
+        return luaEnumString_RenderStateDepthFunction_DEPTH_LESS;
+    if (e == RenderState::DEPTH_EQUAL)
+        return luaEnumString_RenderStateDepthFunction_DEPTH_EQUAL;
+    if (e == RenderState::DEPTH_LEQUAL)
+        return luaEnumString_RenderStateDepthFunction_DEPTH_LEQUAL;
+    if (e == RenderState::DEPTH_GREATER)
+        return luaEnumString_RenderStateDepthFunction_DEPTH_GREATER;
+    if (e == RenderState::DEPTH_NOTEQUAL)
+        return luaEnumString_RenderStateDepthFunction_DEPTH_NOTEQUAL;
+    if (e == RenderState::DEPTH_GEQUAL)
+        return luaEnumString_RenderStateDepthFunction_DEPTH_GEQUAL;
+    if (e == RenderState::DEPTH_ALWAYS)
+        return luaEnumString_RenderStateDepthFunction_DEPTH_ALWAYS;
+    return enumStringEmpty;
+}
+
+}
+

gameplay/src/lua/lua_SceneDebugFlags.cpp

@@ -15,7 +15,6 @@ Scene::DebugFlags lua_enumFromString_SceneDebugFlags(const char* s)
         return Scene::DEBUG_BOXES;
     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;
 }
 
@@ -25,7 +24,6 @@ const char* lua_stringFromEnum_SceneDebugFlags(Scene::DebugFlags e)
         return luaEnumString_SceneDebugFlags_DEBUG_BOXES;
     if (e == Scene::DEBUG_SPHERES)
         return luaEnumString_SceneDebugFlags_DEBUG_SPHERES;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Scene::DebugFlags.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_TerrainFlags.cpp

@@ -1,38 +1,36 @@
-#include "Base.h"
-#include "lua_TerrainFlags.h"
-
-namespace gameplay
-{
-
-static const char* enumStringEmpty = "";
-
-static const char* luaEnumString_TerrainFlags_DEBUG_PATCHES = "DEBUG_PATCHES";
-static const char* luaEnumString_TerrainFlags_FRUSTUM_CULLING = "FRUSTUM_CULLING";
-static const char* luaEnumString_TerrainFlags_LEVEL_OF_DETAIL = "LEVEL_OF_DETAIL";
-
-Terrain::Flags lua_enumFromString_TerrainFlags(const char* s)
-{
-    if (strcmp(s, luaEnumString_TerrainFlags_DEBUG_PATCHES) == 0)
-        return Terrain::DEBUG_PATCHES;
-    if (strcmp(s, luaEnumString_TerrainFlags_FRUSTUM_CULLING) == 0)
-        return Terrain::FRUSTUM_CULLING;
-    if (strcmp(s, luaEnumString_TerrainFlags_LEVEL_OF_DETAIL) == 0)
-        return Terrain::LEVEL_OF_DETAIL;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration Terrain::Flags.", s);
-    return Terrain::DEBUG_PATCHES;
-}
-
-const char* lua_stringFromEnum_TerrainFlags(Terrain::Flags e)
-{
-    if (e == Terrain::DEBUG_PATCHES)
-        return luaEnumString_TerrainFlags_DEBUG_PATCHES;
-    if (e == Terrain::FRUSTUM_CULLING)
-        return luaEnumString_TerrainFlags_FRUSTUM_CULLING;
-    if (e == Terrain::LEVEL_OF_DETAIL)
-        return luaEnumString_TerrainFlags_LEVEL_OF_DETAIL;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Terrain::Flags.", e);
-    return enumStringEmpty;
-}
-
-}
-
+#include "Base.h"
+#include "lua_TerrainFlags.h"
+
+namespace gameplay
+{
+
+static const char* enumStringEmpty = "";
+
+static const char* luaEnumString_TerrainFlags_DEBUG_PATCHES = "DEBUG_PATCHES";
+static const char* luaEnumString_TerrainFlags_FRUSTUM_CULLING = "FRUSTUM_CULLING";
+static const char* luaEnumString_TerrainFlags_LEVEL_OF_DETAIL = "LEVEL_OF_DETAIL";
+
+Terrain::Flags lua_enumFromString_TerrainFlags(const char* s)
+{
+    if (strcmp(s, luaEnumString_TerrainFlags_DEBUG_PATCHES) == 0)
+        return Terrain::DEBUG_PATCHES;
+    if (strcmp(s, luaEnumString_TerrainFlags_FRUSTUM_CULLING) == 0)
+        return Terrain::FRUSTUM_CULLING;
+    if (strcmp(s, luaEnumString_TerrainFlags_LEVEL_OF_DETAIL) == 0)
+        return Terrain::LEVEL_OF_DETAIL;
+    return Terrain::DEBUG_PATCHES;
+}
+
+const char* lua_stringFromEnum_TerrainFlags(Terrain::Flags e)
+{
+    if (e == Terrain::DEBUG_PATCHES)
+        return luaEnumString_TerrainFlags_DEBUG_PATCHES;
+    if (e == Terrain::FRUSTUM_CULLING)
+        return luaEnumString_TerrainFlags_FRUSTUM_CULLING;
+    if (e == Terrain::LEVEL_OF_DETAIL)
+        return luaEnumString_TerrainFlags_LEVEL_OF_DETAIL;
+    return enumStringEmpty;
+}
+
+}
+

gameplay/src/lua/lua_TextureFilter.cpp

@@ -27,7 +27,6 @@ Texture::Filter lua_enumFromString_TextureFilter(const char* s)
         return Texture::NEAREST_MIPMAP_LINEAR;
     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;
 }
 
@@ -45,7 +44,6 @@ const char* lua_stringFromEnum_TextureFilter(Texture::Filter e)
         return luaEnumString_TextureFilter_NEAREST_MIPMAP_LINEAR;
     if (e == Texture::LINEAR_MIPMAP_LINEAR)
         return luaEnumString_TextureFilter_LINEAR_MIPMAP_LINEAR;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Texture::Filter.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_TextureFormat.cpp

@@ -21,7 +21,6 @@ Texture::Format lua_enumFromString_TextureFormat(const char* s)
         return Texture::RGBA;
     if (strcmp(s, luaEnumString_TextureFormat_ALPHA) == 0)
         return Texture::ALPHA;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration Texture::Format.", s);
     return Texture::UNKNOWN;
 }
 
@@ -35,7 +34,6 @@ const char* lua_stringFromEnum_TextureFormat(Texture::Format e)
         return luaEnumString_TextureFormat_RGBA;
     if (e == Texture::ALPHA)
         return luaEnumString_TextureFormat_ALPHA;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Texture::Format.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_TextureWrap.cpp

@@ -15,7 +15,6 @@ Texture::Wrap lua_enumFromString_TextureWrap(const char* s)
         return Texture::REPEAT;
     if (strcmp(s, luaEnumString_TextureWrap_CLAMP) == 0)
         return Texture::CLAMP;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration Texture::Wrap.", s);
     return Texture::REPEAT;
 }
 
@@ -25,7 +24,6 @@ const char* lua_stringFromEnum_TextureWrap(Texture::Wrap e)
         return luaEnumString_TextureWrap_REPEAT;
     if (e == Texture::CLAMP)
         return luaEnumString_TextureWrap_CLAMP;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Texture::Wrap.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_TouchTouchEvent.cpp

@@ -18,7 +18,6 @@ Touch::TouchEvent lua_enumFromString_TouchTouchEvent(const char* s)
         return Touch::TOUCH_RELEASE;
     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;
 }
 
@@ -30,7 +29,6 @@ const char* lua_stringFromEnum_TouchTouchEvent(Touch::TouchEvent e)
         return luaEnumString_TouchTouchEvent_TOUCH_RELEASE;
     if (e == Touch::TOUCH_MOVE)
         return luaEnumString_TouchTouchEvent_TOUCH_MOVE;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration Touch::TouchEvent.", e);
     return enumStringEmpty;
 }
 

gameplay/src/lua/lua_VertexFormatUsage.cpp

@@ -54,7 +54,6 @@ VertexFormat::Usage lua_enumFromString_VertexFormatUsage(const char* s)
         return VertexFormat::TEXCOORD6;
     if (strcmp(s, luaEnumString_VertexFormatUsage_TEXCOORD7) == 0)
         return VertexFormat::TEXCOORD7;
-    GP_ERROR("Invalid enumeration value '%s' for enumeration VertexFormat::Usage.", s);
     return VertexFormat::POSITION;
 }
 
@@ -90,7 +89,6 @@ const char* lua_stringFromEnum_VertexFormatUsage(VertexFormat::Usage e)
         return luaEnumString_VertexFormatUsage_TEXCOORD6;
     if (e == VertexFormat::TEXCOORD7)
         return luaEnumString_VertexFormatUsage_TEXCOORD7;
-    GP_ERROR("Invalid enumeration value '%d' for enumeration VertexFormat::Usage.", e);
     return enumStringEmpty;
 }
 

tools/luagen/src/Generator.cpp

@@ -1509,7 +1509,7 @@ void Generator::generateBindings(string* bindingNS)
 
                     if (i == iter->second.values.size() - 1)
                     {
-                        enumCpp << "    GP_ERROR(\"Invalid enumeration value '%s' for enumeration " << iter->first << ".\", s);\n";
+                        //enumCpp << "    GP_ERROR(\"Invalid enumeration value '%s' for enumeration " << iter->first << ".\", s);\n";
                         enumCpp << "    return ";
                         if (scope.size() > 0)
                             enumCpp << scope;
@@ -1535,7 +1535,7 @@ void Generator::generateBindings(string* bindingNS)
 
                     if (i == iter->second.values.size() - 1)
                     {
-                        enumCpp << "    GP_ERROR(\"Invalid enumeration value '%d' for enumeration " << iter->first << ".\", e);\n";
+                        //enumCpp << "    GP_ERROR(\"Invalid enumeration value '%d' for enumeration " << iter->first << ".\", e);\n";
                         enumCpp << "    return enumStringEmpty;\n";
                     }
                 }