Merge remote-tracking branch 'upstream/next' into next

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/Container.cpp

@@ -645,7 +645,7 @@ bool Container::keyEvent(Keyboard::KeyEvent evt, int key)
             continue;
         }
 
-        if (control->isInFocus() && control->keyEvent(evt, key))
+        if (control->hasFocus() && control->keyEvent(evt, key))
         {
             release();
             return true;
@@ -677,7 +677,7 @@ void Container::guaranteeFocus(Control* inFocus)
         {
             ((Container*)control)->guaranteeFocus(inFocus);
         }
-        else if (control->isInFocus())
+        else if (control->hasFocus())
         {
             control->setState(NORMAL);
             return;
@@ -697,7 +697,7 @@ bool Container::moveFocus(Direction direction, Control* outsideControl)
         {
             Control* control = *it;
             GP_ASSERT(control);
-            if (control->isInFocus())
+            if (control->hasFocus())
             {
                 start = control;
                 break;
@@ -904,7 +904,7 @@ bool Container::moveFocus(Direction direction, Control* outsideControl)
 void Container::timeEvent(long timeDiff, void* cookie)
 {
     double time = Game::getAbsoluteTime();
-    if (_focusChangeRepeat && isInFocus() && _focusPressed &&
+    if (_focusChangeRepeat && hasFocus() && _focusPressed &&
         abs(time - timeDiff - _focusChangeRepeatDelay - _focusChangeStartTime) < 50)
     {
         ++_focusChangeCount;
@@ -961,7 +961,7 @@ bool Container::gamepadEvent(Gamepad::GamepadEvent evt, Gamepad* gamepad, unsign
     {
         Control* control = *it;
         GP_ASSERT(control);
-        if (control->isInFocus() || control->getState() == Control::ACTIVE)
+        if (control->hasFocus() || control->getState() == Control::ACTIVE)
         {
             eventConsumed |= control->gamepadEvent(evt, gamepad, analogIndex);
             break;

gameplay/src/Control.cpp

@@ -275,7 +275,7 @@ bool Control::isVisible() const
     return _visible;
 }
 
-bool Control::isInFocus() const
+bool Control::hasFocus() const
 {
     return (_state == FOCUS || (_state == HOVER && _previousState == FOCUS));
 }

gameplay/src/Control.h

@@ -630,14 +630,6 @@ public:
      */
     bool isVisible() const;
 
-    /**
-     * Gets whether this control is in focus.
-     * Note that a control's state can be HOVER while the control is in focus.
-     * When the cursor leaves the control, it will return to the FOCUS state.
-     * This method will still return true in this case.
-     */
-    bool isInFocus() const;
-
     /**
      * Set the opacity of this control.
      *
@@ -964,7 +956,6 @@ protected:
      *
      * @param eventType The event to trigger.
      */
-    //void notifyListeners(Listener::EventType eventType);
     void notifyListeners(Control::Listener::EventType eventType);
 
     /**
@@ -975,6 +966,14 @@ protected:
      */
     static Alignment getAlignment(const char* alignment);
 
+    /**
+     * Gets whether this control is in focus.
+     * Note that a control's state can be HOVER while the control is in focus.
+     * When the cursor leaves the control, it will return to the FOCUS state.
+     * This method will still return true in this case.
+     */
+    bool hasFocus() const;
+
     /** 
      * The Control's ID.
      */ 

gameplay/src/Form.cpp

@@ -603,7 +603,7 @@ void Form::updateInternal(float elapsedTime)
 
 static bool shouldPropagateTouchEvent(Control::State state, Touch::TouchEvent evt, const Rectangle& bounds, int x, int y)
 {
-    return (state == Control::FOCUS ||
+    return (state != Control::NORMAL ||
             (evt == Touch::TOUCH_PRESS &&
              x >= bounds.x &&
              x <= bounds.x + bounds.width &&
@@ -659,7 +659,7 @@ bool Form::keyEventInternal(Keyboard::KeyEvent evt, int key)
     {
         Form* form = __forms[i];
         GP_ASSERT(form);
-        if (form->isEnabled() && form->isVisible() && form->getState() == Control::FOCUS)
+        if (form->isEnabled() && form->isVisible() && form->hasFocus())
         {
             if (form->keyEvent(evt, key))
                 return true;
@@ -727,7 +727,7 @@ void Form::gamepadEventInternal(Gamepad::GamepadEvent evt, Gamepad* gamepad, uns
         Form* form = __forms[i];
         GP_ASSERT(form);
 
-        if (form->isEnabled() && form->isVisible() && form->isInFocus())
+        if (form->isEnabled() && form->isVisible() && form->hasFocus())
         {
             if (form->gamepadEvent(evt, gamepad, analogIndex))
                 return;

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/Slider.cpp

@@ -262,7 +262,7 @@ bool Slider::mouseEvent(Mouse::MouseEvent evt, int x, int y, int wheelDelta)
 
         case Mouse::MOUSE_WHEEL:
         {
-            if ((isInFocus() && _state == HOVER) || _state == ACTIVE)
+            if ((hasFocus() && _state == HOVER) || _state == ACTIVE)
             {
                 float total = _max - _min;
                 float oldValue = _value;
@@ -366,7 +366,7 @@ bool Slider::gamepadEvent(Gamepad::GamepadEvent evt, Gamepad* gamepad, unsigned
         {
             _selectButtonDown = false;
 
-            if (isInFocus())
+            if (hasFocus())
                 setState(ACTIVE);
             else if (_state == ACTIVE)
                 setState(FOCUS);

gameplay/src/TextBox.cpp

@@ -105,209 +105,206 @@ bool TextBox::touchEvent(Touch::TouchEvent evt, int x, int y, unsigned int conta
 
 bool TextBox::keyEvent(Keyboard::KeyEvent evt, int key)
 {
-    if (isInFocus())
+    switch (evt)
     {
-        switch (evt)
+        case Keyboard::KEY_PRESS:
         {
-            case Keyboard::KEY_PRESS:
+            switch (key)
             {
-                switch (key)
+                case Keyboard::KEY_HOME:
                 {
-                    case Keyboard::KEY_HOME:
-                    {
-                        // TODO: Move cursor to beginning of line.
-                        // This only works for left alignment...
+                    // TODO: Move cursor to beginning of line.
+                    // This only works for left alignment...
                         
-                        //_caretLocation.x = _viewportClipBounds.x;
-                        //_dirty = true;
-                        break;
-                    }
-                    case Keyboard::KEY_END:
-                    {
-                        // TODO: Move cursor to end of line.
-                        break;
-                    }
-                    case Keyboard::KEY_DELETE:
-                    {
-                        Font* font = getFont(_state);
-                        GP_ASSERT(font);
-                        unsigned int fontSize = getFontSize(_state);
-                        Font::Justify textAlignment = getTextAlignment(_state);
-                        bool rightToLeft = getTextRightToLeft(_state);
+                    //_caretLocation.x = _viewportClipBounds.x;
+                    //_dirty = true;
+                    break;
+                }
+                case Keyboard::KEY_END:
+                {
+                    // TODO: Move cursor to end of line.
+                    break;
+                }
+                case Keyboard::KEY_DELETE:
+                {
+                    Font* font = getFont(_state);
+                    GP_ASSERT(font);
+                    unsigned int fontSize = getFontSize(_state);
+                    Font::Justify textAlignment = getTextAlignment(_state);
+                    bool rightToLeft = getTextRightToLeft(_state);
 
-                        int textIndex = font->getIndexAtLocation(_text.c_str(), _textBounds, fontSize, _caretLocation, &_caretLocation,
-                            textAlignment, true, rightToLeft);
+                    int textIndex = font->getIndexAtLocation(_text.c_str(), _textBounds, fontSize, _caretLocation, &_caretLocation,
+                        textAlignment, true, rightToLeft);
                         
-                        _text.erase(textIndex, 1);
-                        font->getLocationAtIndex(_text.c_str(), _textBounds, fontSize, &_caretLocation, textIndex,
-                            textAlignment, true, rightToLeft);
-                        _dirty = true;
-                        notifyListeners(Control::Listener::TEXT_CHANGED);
-                        break;
-                    }
-                    case Keyboard::KEY_LEFT_ARROW:
-                    {
-                        Font* font = getFont(_state);
-                        GP_ASSERT(font);
-                        unsigned int fontSize = getFontSize(_state);
-                        Font::Justify textAlignment = getTextAlignment(_state);
-                        bool rightToLeft = getTextRightToLeft(_state);
+                    _text.erase(textIndex, 1);
+                    font->getLocationAtIndex(_text.c_str(), _textBounds, fontSize, &_caretLocation, textIndex,
+                        textAlignment, true, rightToLeft);
+                    _dirty = true;
+                    notifyListeners(Control::Listener::TEXT_CHANGED);
+                    break;
+                }
+                case Keyboard::KEY_LEFT_ARROW:
+                {
+                    Font* font = getFont(_state);
+                    GP_ASSERT(font);
+                    unsigned int fontSize = getFontSize(_state);
+                    Font::Justify textAlignment = getTextAlignment(_state);
+                    bool rightToLeft = getTextRightToLeft(_state);
 
-                        int textIndex = font->getIndexAtLocation(_text.c_str(), _textBounds, fontSize, _caretLocation, &_caretLocation,
-                            textAlignment, true, rightToLeft);
-                        font->getLocationAtIndex(_text.c_str(), _textBounds, fontSize, &_caretLocation, textIndex - 1,
-                            textAlignment, true, rightToLeft);
-                        _dirty = true;
-                        break;
-                    }
-                    case Keyboard::KEY_RIGHT_ARROW:
-                    {
-                        Font* font = getFont(_state);
-                        GP_ASSERT(font);
-                        unsigned int fontSize = getFontSize(_state);
-                        Font::Justify textAlignment = getTextAlignment(_state);
-                        bool rightToLeft = getTextRightToLeft(_state);
+                    int textIndex = font->getIndexAtLocation(_text.c_str(), _textBounds, fontSize, _caretLocation, &_caretLocation,
+                        textAlignment, true, rightToLeft);
+                    font->getLocationAtIndex(_text.c_str(), _textBounds, fontSize, &_caretLocation, textIndex - 1,
+                        textAlignment, true, rightToLeft);
+                    _dirty = true;
+                    break;
+                }
+                case Keyboard::KEY_RIGHT_ARROW:
+                {
+                    Font* font = getFont(_state);
+                    GP_ASSERT(font);
+                    unsigned int fontSize = getFontSize(_state);
+                    Font::Justify textAlignment = getTextAlignment(_state);
+                    bool rightToLeft = getTextRightToLeft(_state);
 
-                        int textIndex = font->getIndexAtLocation(_text.c_str(), _textBounds, fontSize, _caretLocation, &_caretLocation,
-                            textAlignment, true, rightToLeft);
-                        font->getLocationAtIndex(_text.c_str(), _textBounds, fontSize, &_caretLocation, textIndex + 1,
-                            textAlignment, true, rightToLeft);
-                        _dirty = true;
-                        break;
-                    }
-                    case Keyboard::KEY_UP_ARROW:
+                    int textIndex = font->getIndexAtLocation(_text.c_str(), _textBounds, fontSize, _caretLocation, &_caretLocation,
+                        textAlignment, true, rightToLeft);
+                    font->getLocationAtIndex(_text.c_str(), _textBounds, fontSize, &_caretLocation, textIndex + 1,
+                        textAlignment, true, rightToLeft);
+                    _dirty = true;
+                    break;
+                }
+                case Keyboard::KEY_UP_ARROW:
+                {
+                    Font* font = getFont(_state);
+                    GP_ASSERT(font);
+                    unsigned int fontSize = getFontSize(_state);
+                    Font::Justify textAlignment = getTextAlignment(_state);
+                    bool rightToLeft = getTextRightToLeft(_state);
+                    _prevCaretLocation.set(_caretLocation);
+                    _caretLocation.y -= fontSize;
+                    int textIndex = font->getIndexAtLocation(_text.c_str(), _textBounds, fontSize, _caretLocation, &_caretLocation,
+                        textAlignment, true, rightToLeft);
+                    if (textIndex == -1)
                     {
-                        Font* font = getFont(_state);
-                        GP_ASSERT(font);
-                        unsigned int fontSize = getFontSize(_state);
-                        Font::Justify textAlignment = getTextAlignment(_state);
-                        bool rightToLeft = getTextRightToLeft(_state);
-                        _prevCaretLocation.set(_caretLocation);
-                        _caretLocation.y -= fontSize;
-                        int textIndex = font->getIndexAtLocation(_text.c_str(), _textBounds, fontSize, _caretLocation, &_caretLocation,
-                            textAlignment, true, rightToLeft);
-                        if (textIndex == -1)
-                        {
-                            _caretLocation.set(_prevCaretLocation);
-                        }
-
-                        _dirty = true;
-                        break;
+                        _caretLocation.set(_prevCaretLocation);
                     }
-                    case Keyboard::KEY_DOWN_ARROW:
-                    {
-                        Font* font = getFont(_state);
-                        GP_ASSERT(font);
-                        unsigned int fontSize = getFontSize(_state);
-                        Font::Justify textAlignment = getTextAlignment(_state);
-                        bool rightToLeft = getTextRightToLeft(_state);
-                        _prevCaretLocation.set(_caretLocation);
-                        _caretLocation.y += fontSize;
-                        int textIndex = font->getIndexAtLocation(_text.c_str(), _textBounds, fontSize, _caretLocation, &_caretLocation,
-                            textAlignment, true, rightToLeft);
-                        if (textIndex == -1)
-                        {
-                            _caretLocation.set(_prevCaretLocation);
-                        }
 
-                        _dirty = true;
-                        break;
+                    _dirty = true;
+                    break;
+                }
+                case Keyboard::KEY_DOWN_ARROW:
+                {
+                    Font* font = getFont(_state);
+                    GP_ASSERT(font);
+                    unsigned int fontSize = getFontSize(_state);
+                    Font::Justify textAlignment = getTextAlignment(_state);
+                    bool rightToLeft = getTextRightToLeft(_state);
+                    _prevCaretLocation.set(_caretLocation);
+                    _caretLocation.y += fontSize;
+                    int textIndex = font->getIndexAtLocation(_text.c_str(), _textBounds, fontSize, _caretLocation, &_caretLocation,
+                        textAlignment, true, rightToLeft);
+                    if (textIndex == -1)
+                    {
+                        _caretLocation.set(_prevCaretLocation);
                     }
+
+                    _dirty = true;
+                    break;
                 }
-                break;
             }
+            break;
+        }
 
-            case Keyboard::KEY_CHAR:
-            {
-                Font* font = getFont(_state);
-                GP_ASSERT(font);
-                unsigned int fontSize = getFontSize(_state);
-                Font::Justify textAlignment = getTextAlignment(_state);
-                bool rightToLeft = getTextRightToLeft(_state);
+        case Keyboard::KEY_CHAR:
+        {
+            Font* font = getFont(_state);
+            GP_ASSERT(font);
+            unsigned int fontSize = getFontSize(_state);
+            Font::Justify textAlignment = getTextAlignment(_state);
+            bool rightToLeft = getTextRightToLeft(_state);
 
-                int textIndex = font->getIndexAtLocation(_text.c_str(), _textBounds, fontSize, _caretLocation, &_caretLocation,
+            int textIndex = font->getIndexAtLocation(_text.c_str(), _textBounds, fontSize, _caretLocation, &_caretLocation,
+                textAlignment, true, rightToLeft);
+            if (textIndex == -1)
+            {
+                textIndex = 0;
+                font->getLocationAtIndex(_text.c_str(), _textBounds, fontSize, &_caretLocation, 0,
                     textAlignment, true, rightToLeft);
-                if (textIndex == -1)
-                {
-                    textIndex = 0;
-                    font->getLocationAtIndex(_text.c_str(), _textBounds, fontSize, &_caretLocation, 0,
-                        textAlignment, true, rightToLeft);
-                }
+            }
 
-                switch (key)
+            switch (key)
+            {
+                case Keyboard::KEY_BACKSPACE:
                 {
-                    case Keyboard::KEY_BACKSPACE:
+                    if (textIndex > 0)
                     {
-                        if (textIndex > 0)
-                        {
-                            --textIndex;
-                            _text.erase(textIndex, 1);
-                            font->getLocationAtIndex(_text.c_str(), _textBounds, fontSize, &_caretLocation, textIndex,
-                                textAlignment, true, rightToLeft);
+                        --textIndex;
+                        _text.erase(textIndex, 1);
+                        font->getLocationAtIndex(_text.c_str(), _textBounds, fontSize, &_caretLocation, textIndex,
+                            textAlignment, true, rightToLeft);
 
-                            _dirty = true;
-                        }
-                        break;
+                        _dirty = true;
                     }
-                    case Keyboard::KEY_RETURN:
-                        // TODO: Handle line-break insertion correctly.
-                        break;
-                    case Keyboard::KEY_ESCAPE:
-                        break;
-                    case Keyboard::KEY_TAB:
-                        // Allow tab to move the focus forward.
-                        return false;
-                        break;
-                    default:
-                    {
-                        // Insert character into string.
-                        _text.insert(textIndex, 1, (char)key);
-
-                        // Get new location of caret.
-                        font->getLocationAtIndex(_text.c_str(), _textBounds, fontSize, &_caretLocation, textIndex + 1,
-                            textAlignment, true, rightToLeft);
+                    break;
+                }
+                case Keyboard::KEY_RETURN:
+                    // TODO: Handle line-break insertion correctly.
+                    break;
+                case Keyboard::KEY_ESCAPE:
+                    break;
+                case Keyboard::KEY_TAB:
+                    // Allow tab to move the focus forward.
+                    return false;
+                    break;
+                default:
+                {
+                    // Insert character into string.
+                    _text.insert(textIndex, 1, (char)key);
 
-                        if (key == ' ')
-                        {
-                            // If a space was entered, check that caret is still within bounds.
-                            if (_caretLocation.x >= _textBounds.x + _textBounds.width ||
-                                _caretLocation.y >= _textBounds.y + _textBounds.height)
-                            {
-                                // If not, undo the character insertion.
-                                _text.erase(textIndex, 1);
-                                font->getLocationAtIndex(_text.c_str(), _textBounds, fontSize, &_caretLocation, textIndex,
-                                    textAlignment, true, rightToLeft);
-
-                                // No need to check again.
-                                break;
-                            }
-                        }
+                    // Get new location of caret.
+                    font->getLocationAtIndex(_text.c_str(), _textBounds, fontSize, &_caretLocation, textIndex + 1,
+                        textAlignment, true, rightToLeft);
 
-                        // Always check that the text still fits within the clip region.
-                        Rectangle textBounds;
-                        font->measureText(_text.c_str(), _textBounds, fontSize, &textBounds, textAlignment, true, true);
-                        if (textBounds.x < _textBounds.x || textBounds.y < _textBounds.y ||
-                            textBounds.width >= _textBounds.width || textBounds.height >= _textBounds.height)
+                    if (key == ' ')
+                    {
+                        // If a space was entered, check that caret is still within bounds.
+                        if (_caretLocation.x >= _textBounds.x + _textBounds.width ||
+                            _caretLocation.y >= _textBounds.y + _textBounds.height)
                         {
                             // If not, undo the character insertion.
                             _text.erase(textIndex, 1);
                             font->getLocationAtIndex(_text.c_str(), _textBounds, fontSize, &_caretLocation, textIndex,
                                 textAlignment, true, rightToLeft);
 
-                            // TextBox is not dirty.
+                            // No need to check again.
                             break;
                         }
-                
-                        _dirty = true;
+                    }
+
+                    // Always check that the text still fits within the clip region.
+                    Rectangle textBounds;
+                    font->measureText(_text.c_str(), _textBounds, fontSize, &textBounds, textAlignment, true, true);
+                    if (textBounds.x < _textBounds.x || textBounds.y < _textBounds.y ||
+                        textBounds.width >= _textBounds.width || textBounds.height >= _textBounds.height)
+                    {
+                        // If not, undo the character insertion.
+                        _text.erase(textIndex, 1);
+                        font->getLocationAtIndex(_text.c_str(), _textBounds, fontSize, &_caretLocation, textIndex,
+                            textAlignment, true, rightToLeft);
+
+                        // TextBox is not dirty.
                         break;
                     }
-            
+                
+                    _dirty = true;
                     break;
                 }
-
-                notifyListeners(Control::Listener::TEXT_CHANGED);
+            
                 break;
             }
+
+            notifyListeners(Control::Listener::TEXT_CHANGED);
+            break;
         }
     }
 
@@ -326,7 +323,7 @@ void TextBox::update(const Control* container, const Vector2& offset)
 
 void TextBox::drawImages(SpriteBatch* spriteBatch, const Rectangle& clip)
 {
-    if (_caretImage && (_state == ACTIVE || isInFocus()))
+    if (_caretImage && (_state == ACTIVE || hasFocus()))
     {
         // Draw the cursor at its current location.
         const Rectangle& region = _caretImage->getRegion();

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_Button.cpp

@@ -74,7 +74,6 @@ void luaRegister_Button()
         {"getZIndex", lua_Button_getZIndex},
         {"isContainer", lua_Button_isContainer},
         {"isEnabled", lua_Button_isEnabled},
-        {"isInFocus", lua_Button_isInFocus},
         {"isVisible", lua_Button_isVisible},
         {"release", lua_Button_release},
         {"removeListener", lua_Button_removeListener},
@@ -2603,41 +2602,6 @@ int lua_Button_isEnabled(lua_State* state)
     return 0;
 }
 
-int lua_Button_isInFocus(lua_State* state)
-{
-    // Get the number of parameters.
-    int paramCount = lua_gettop(state);
-
-    // Attempt to match the parameters to a valid binding.
-    switch (paramCount)
-    {
-        case 1:
-        {
-            if ((lua_type(state, 1) == LUA_TUSERDATA))
-            {
-                Button* instance = getInstance(state);
-                bool result = instance->isInFocus();
-
-                // Push the return value onto the stack.
-                lua_pushboolean(state, result);
-
-                return 1;
-            }
-
-            lua_pushstring(state, "lua_Button_isInFocus - Failed to match the given parameters to a valid function signature.");
-            lua_error(state);
-            break;
-        }
-        default:
-        {
-            lua_pushstring(state, "Invalid number of parameters (expected 1).");
-            lua_error(state);
-            break;
-        }
-    }
-    return 0;
-}
-
 int lua_Button_isVisible(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_Button.h

@@ -54,7 +54,6 @@ int lua_Button_getY(lua_State* state);
 int lua_Button_getZIndex(lua_State* state);
 int lua_Button_isContainer(lua_State* state);
 int lua_Button_isEnabled(lua_State* state);
-int lua_Button_isInFocus(lua_State* state);
 int lua_Button_isVisible(lua_State* state);
 int lua_Button_release(lua_State* state);
 int lua_Button_removeListener(lua_State* state);

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_CheckBox.cpp

@@ -78,7 +78,6 @@ void luaRegister_CheckBox()
         {"isChecked", lua_CheckBox_isChecked},
         {"isContainer", lua_CheckBox_isContainer},
         {"isEnabled", lua_CheckBox_isEnabled},
-        {"isInFocus", lua_CheckBox_isInFocus},
         {"isVisible", lua_CheckBox_isVisible},
         {"release", lua_CheckBox_release},
         {"removeListener", lua_CheckBox_removeListener},
@@ -2723,41 +2722,6 @@ int lua_CheckBox_isEnabled(lua_State* state)
     return 0;
 }
 
-int lua_CheckBox_isInFocus(lua_State* state)
-{
-    // Get the number of parameters.
-    int paramCount = lua_gettop(state);
-
-    // Attempt to match the parameters to a valid binding.
-    switch (paramCount)
-    {
-        case 1:
-        {
-            if ((lua_type(state, 1) == LUA_TUSERDATA))
-            {
-                CheckBox* instance = getInstance(state);
-                bool result = instance->isInFocus();
-
-                // Push the return value onto the stack.
-                lua_pushboolean(state, result);
-
-                return 1;
-            }
-
-            lua_pushstring(state, "lua_CheckBox_isInFocus - Failed to match the given parameters to a valid function signature.");
-            lua_error(state);
-            break;
-        }
-        default:
-        {
-            lua_pushstring(state, "Invalid number of parameters (expected 1).");
-            lua_error(state);
-            break;
-        }
-    }
-    return 0;
-}
-
 int lua_CheckBox_isVisible(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_CheckBox.h

@@ -57,7 +57,6 @@ int lua_CheckBox_getZIndex(lua_State* state);
 int lua_CheckBox_isChecked(lua_State* state);
 int lua_CheckBox_isContainer(lua_State* state);
 int lua_CheckBox_isEnabled(lua_State* state);
-int lua_CheckBox_isInFocus(lua_State* state);
 int lua_CheckBox_isVisible(lua_State* state);
 int lua_CheckBox_release(lua_State* state);
 int lua_CheckBox_removeListener(lua_State* state);

gameplay/src/lua/lua_Container.cpp

@@ -94,7 +94,6 @@ void luaRegister_Container()
         {"insertControl", lua_Container_insertControl},
         {"isContainer", lua_Container_isContainer},
         {"isEnabled", lua_Container_isEnabled},
-        {"isInFocus", lua_Container_isInFocus},
         {"isScrollBarsAutoHide", lua_Container_isScrollBarsAutoHide},
         {"isScrolling", lua_Container_isScrolling},
         {"isVisible", lua_Container_isVisible},
@@ -2984,41 +2983,6 @@ int lua_Container_isEnabled(lua_State* state)
     return 0;
 }
 
-int lua_Container_isInFocus(lua_State* state)
-{
-    // Get the number of parameters.
-    int paramCount = lua_gettop(state);
-
-    // Attempt to match the parameters to a valid binding.
-    switch (paramCount)
-    {
-        case 1:
-        {
-            if ((lua_type(state, 1) == LUA_TUSERDATA))
-            {
-                Container* instance = getInstance(state);
-                bool result = instance->isInFocus();
-
-                // Push the return value onto the stack.
-                lua_pushboolean(state, result);
-
-                return 1;
-            }
-
-            lua_pushstring(state, "lua_Container_isInFocus - Failed to match the given parameters to a valid function signature.");
-            lua_error(state);
-            break;
-        }
-        default:
-        {
-            lua_pushstring(state, "Invalid number of parameters (expected 1).");
-            lua_error(state);
-            break;
-        }
-    }
-    return 0;
-}
-
 int lua_Container_isScrollBarsAutoHide(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_Container.h

@@ -62,7 +62,6 @@ int lua_Container_getZIndex(lua_State* state);
 int lua_Container_insertControl(lua_State* state);
 int lua_Container_isContainer(lua_State* state);
 int lua_Container_isEnabled(lua_State* state);
-int lua_Container_isInFocus(lua_State* state);
 int lua_Container_isScrollBarsAutoHide(lua_State* state);
 int lua_Container_isScrolling(lua_State* state);
 int lua_Container_isVisible(lua_State* state);

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_Control.cpp

@@ -71,7 +71,6 @@ void luaRegister_Control()
         {"getZIndex", lua_Control_getZIndex},
         {"isContainer", lua_Control_isContainer},
         {"isEnabled", lua_Control_isEnabled},
-        {"isInFocus", lua_Control_isInFocus},
         {"isVisible", lua_Control_isVisible},
         {"release", lua_Control_release},
         {"removeListener", lua_Control_removeListener},
@@ -2598,41 +2597,6 @@ int lua_Control_isEnabled(lua_State* state)
     return 0;
 }
 
-int lua_Control_isInFocus(lua_State* state)
-{
-    // Get the number of parameters.
-    int paramCount = lua_gettop(state);
-
-    // Attempt to match the parameters to a valid binding.
-    switch (paramCount)
-    {
-        case 1:
-        {
-            if ((lua_type(state, 1) == LUA_TUSERDATA))
-            {
-                Control* instance = getInstance(state);
-                bool result = instance->isInFocus();
-
-                // Push the return value onto the stack.
-                lua_pushboolean(state, result);
-
-                return 1;
-            }
-
-            lua_pushstring(state, "lua_Control_isInFocus - Failed to match the given parameters to a valid function signature.");
-            lua_error(state);
-            break;
-        }
-        default:
-        {
-            lua_pushstring(state, "Invalid number of parameters (expected 1).");
-            lua_error(state);
-            break;
-        }
-    }
-    return 0;
-}
-
 int lua_Control_isVisible(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_Control.h

@@ -54,7 +54,6 @@ int lua_Control_getY(lua_State* state);
 int lua_Control_getZIndex(lua_State* state);
 int lua_Control_isContainer(lua_State* state);
 int lua_Control_isEnabled(lua_State* state);
-int lua_Control_isInFocus(lua_State* state);
 int lua_Control_isVisible(lua_State* state);
 int lua_Control_release(lua_State* state);
 int lua_Control_removeListener(lua_State* state);

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_Form.cpp

@@ -99,7 +99,6 @@ void luaRegister_Form()
         {"insertControl", lua_Form_insertControl},
         {"isContainer", lua_Form_isContainer},
         {"isEnabled", lua_Form_isEnabled},
-        {"isInFocus", lua_Form_isInFocus},
         {"isScrollBarsAutoHide", lua_Form_isScrollBarsAutoHide},
         {"isScrolling", lua_Form_isScrolling},
         {"isVisible", lua_Form_isVisible},
@@ -3068,41 +3067,6 @@ int lua_Form_isEnabled(lua_State* state)
     return 0;
 }
 
-int lua_Form_isInFocus(lua_State* state)
-{
-    // Get the number of parameters.
-    int paramCount = lua_gettop(state);
-
-    // Attempt to match the parameters to a valid binding.
-    switch (paramCount)
-    {
-        case 1:
-        {
-            if ((lua_type(state, 1) == LUA_TUSERDATA))
-            {
-                Form* instance = getInstance(state);
-                bool result = instance->isInFocus();
-
-                // Push the return value onto the stack.
-                lua_pushboolean(state, result);
-
-                return 1;
-            }
-
-            lua_pushstring(state, "lua_Form_isInFocus - Failed to match the given parameters to a valid function signature.");
-            lua_error(state);
-            break;
-        }
-        default:
-        {
-            lua_pushstring(state, "Invalid number of parameters (expected 1).");
-            lua_error(state);
-            break;
-        }
-    }
-    return 0;
-}
-
 int lua_Form_isScrollBarsAutoHide(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_Form.h

@@ -64,7 +64,6 @@ int lua_Form_getZIndex(lua_State* state);
 int lua_Form_insertControl(lua_State* state);
 int lua_Form_isContainer(lua_State* state);
 int lua_Form_isEnabled(lua_State* state);
-int lua_Form_isInFocus(lua_State* state);
 int lua_Form_isScrollBarsAutoHide(lua_State* state);
 int lua_Form_isScrolling(lua_State* state);
 int lua_Form_isVisible(lua_State* state);

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_ImageControl.cpp

@@ -78,7 +78,6 @@ void luaRegister_ImageControl()
         {"getZIndex", lua_ImageControl_getZIndex},
         {"isContainer", lua_ImageControl_isContainer},
         {"isEnabled", lua_ImageControl_isEnabled},
-        {"isInFocus", lua_ImageControl_isInFocus},
         {"isVisible", lua_ImageControl_isVisible},
         {"release", lua_ImageControl_release},
         {"removeListener", lua_ImageControl_removeListener},
@@ -2733,41 +2732,6 @@ int lua_ImageControl_isEnabled(lua_State* state)
     return 0;
 }
 
-int lua_ImageControl_isInFocus(lua_State* state)
-{
-    // Get the number of parameters.
-    int paramCount = lua_gettop(state);
-
-    // Attempt to match the parameters to a valid binding.
-    switch (paramCount)
-    {
-        case 1:
-        {
-            if ((lua_type(state, 1) == LUA_TUSERDATA))
-            {
-                ImageControl* instance = getInstance(state);
-                bool result = instance->isInFocus();
-
-                // Push the return value onto the stack.
-                lua_pushboolean(state, result);
-
-                return 1;
-            }
-
-            lua_pushstring(state, "lua_ImageControl_isInFocus - Failed to match the given parameters to a valid function signature.");
-            lua_error(state);
-            break;
-        }
-        default:
-        {
-            lua_pushstring(state, "Invalid number of parameters (expected 1).");
-            lua_error(state);
-            break;
-        }
-    }
-    return 0;
-}
-
 int lua_ImageControl_isVisible(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_ImageControl.h

@@ -57,7 +57,6 @@ int lua_ImageControl_getY(lua_State* state);
 int lua_ImageControl_getZIndex(lua_State* state);
 int lua_ImageControl_isContainer(lua_State* state);
 int lua_ImageControl_isEnabled(lua_State* state);
-int lua_ImageControl_isInFocus(lua_State* state);
 int lua_ImageControl_isVisible(lua_State* state);
 int lua_ImageControl_release(lua_State* state);
 int lua_ImageControl_removeListener(lua_State* state);

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_Joystick.cpp

@@ -76,7 +76,6 @@ void luaRegister_Joystick()
         {"getZIndex", lua_Joystick_getZIndex},
         {"isContainer", lua_Joystick_isContainer},
         {"isEnabled", lua_Joystick_isEnabled},
-        {"isInFocus", lua_Joystick_isInFocus},
         {"isRelative", lua_Joystick_isRelative},
         {"isVisible", lua_Joystick_isVisible},
         {"release", lua_Joystick_release},
@@ -2775,41 +2774,6 @@ int lua_Joystick_isEnabled(lua_State* state)
     return 0;
 }
 
-int lua_Joystick_isInFocus(lua_State* state)
-{
-    // Get the number of parameters.
-    int paramCount = lua_gettop(state);
-
-    // Attempt to match the parameters to a valid binding.
-    switch (paramCount)
-    {
-        case 1:
-        {
-            if ((lua_type(state, 1) == LUA_TUSERDATA))
-            {
-                Joystick* instance = getInstance(state);
-                bool result = instance->isInFocus();
-
-                // Push the return value onto the stack.
-                lua_pushboolean(state, result);
-
-                return 1;
-            }
-
-            lua_pushstring(state, "lua_Joystick_isInFocus - Failed to match the given parameters to a valid function signature.");
-            lua_error(state);
-            break;
-        }
-        default:
-        {
-            lua_pushstring(state, "Invalid number of parameters (expected 1).");
-            lua_error(state);
-            break;
-        }
-    }
-    return 0;
-}
-
 int lua_Joystick_isRelative(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_Joystick.h

@@ -58,7 +58,6 @@ int lua_Joystick_getY(lua_State* state);
 int lua_Joystick_getZIndex(lua_State* state);
 int lua_Joystick_isContainer(lua_State* state);
 int lua_Joystick_isEnabled(lua_State* state);
-int lua_Joystick_isInFocus(lua_State* state);
 int lua_Joystick_isRelative(lua_State* state);
 int lua_Joystick_isVisible(lua_State* state);
 int lua_Joystick_release(lua_State* state);

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_Label.cpp

@@ -73,7 +73,6 @@ void luaRegister_Label()
         {"getZIndex", lua_Label_getZIndex},
         {"isContainer", lua_Label_isContainer},
         {"isEnabled", lua_Label_isEnabled},
-        {"isInFocus", lua_Label_isInFocus},
         {"isVisible", lua_Label_isVisible},
         {"release", lua_Label_release},
         {"removeListener", lua_Label_removeListener},
@@ -2637,41 +2636,6 @@ int lua_Label_isEnabled(lua_State* state)
     return 0;
 }
 
-int lua_Label_isInFocus(lua_State* state)
-{
-    // Get the number of parameters.
-    int paramCount = lua_gettop(state);
-
-    // Attempt to match the parameters to a valid binding.
-    switch (paramCount)
-    {
-        case 1:
-        {
-            if ((lua_type(state, 1) == LUA_TUSERDATA))
-            {
-                Label* instance = getInstance(state);
-                bool result = instance->isInFocus();
-
-                // Push the return value onto the stack.
-                lua_pushboolean(state, result);
-
-                return 1;
-            }
-
-            lua_pushstring(state, "lua_Label_isInFocus - Failed to match the given parameters to a valid function signature.");
-            lua_error(state);
-            break;
-        }
-        default:
-        {
-            lua_pushstring(state, "Invalid number of parameters (expected 1).");
-            lua_error(state);
-            break;
-        }
-    }
-    return 0;
-}
-
 int lua_Label_isVisible(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_Label.h

@@ -55,7 +55,6 @@ int lua_Label_getY(lua_State* state);
 int lua_Label_getZIndex(lua_State* state);
 int lua_Label_isContainer(lua_State* state);
 int lua_Label_isEnabled(lua_State* state);
-int lua_Label_isInFocus(lua_State* state);
 int lua_Label_isVisible(lua_State* state);
 int lua_Label_release(lua_State* state);
 int lua_Label_removeListener(lua_State* state);

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_RadioButton.cpp

@@ -78,7 +78,6 @@ void luaRegister_RadioButton()
         {"getZIndex", lua_RadioButton_getZIndex},
         {"isContainer", lua_RadioButton_isContainer},
         {"isEnabled", lua_RadioButton_isEnabled},
-        {"isInFocus", lua_RadioButton_isInFocus},
         {"isSelected", lua_RadioButton_isSelected},
         {"isVisible", lua_RadioButton_isVisible},
         {"release", lua_RadioButton_release},
@@ -2725,41 +2724,6 @@ int lua_RadioButton_isEnabled(lua_State* state)
     return 0;
 }
 
-int lua_RadioButton_isInFocus(lua_State* state)
-{
-    // Get the number of parameters.
-    int paramCount = lua_gettop(state);
-
-    // Attempt to match the parameters to a valid binding.
-    switch (paramCount)
-    {
-        case 1:
-        {
-            if ((lua_type(state, 1) == LUA_TUSERDATA))
-            {
-                RadioButton* instance = getInstance(state);
-                bool result = instance->isInFocus();
-
-                // Push the return value onto the stack.
-                lua_pushboolean(state, result);
-
-                return 1;
-            }
-
-            lua_pushstring(state, "lua_RadioButton_isInFocus - Failed to match the given parameters to a valid function signature.");
-            lua_error(state);
-            break;
-        }
-        default:
-        {
-            lua_pushstring(state, "Invalid number of parameters (expected 1).");
-            lua_error(state);
-            break;
-        }
-    }
-    return 0;
-}
-
 int lua_RadioButton_isSelected(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_RadioButton.h

@@ -57,7 +57,6 @@ int lua_RadioButton_getY(lua_State* state);
 int lua_RadioButton_getZIndex(lua_State* state);
 int lua_RadioButton_isContainer(lua_State* state);
 int lua_RadioButton_isEnabled(lua_State* state);
-int lua_RadioButton_isInFocus(lua_State* state);
 int lua_RadioButton_isSelected(lua_State* state);
 int lua_RadioButton_isVisible(lua_State* state);
 int lua_RadioButton_release(lua_State* state);

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_Slider.cpp

@@ -80,7 +80,6 @@ void luaRegister_Slider()
         {"getZIndex", lua_Slider_getZIndex},
         {"isContainer", lua_Slider_isContainer},
         {"isEnabled", lua_Slider_isEnabled},
-        {"isInFocus", lua_Slider_isInFocus},
         {"isValueTextVisible", lua_Slider_isValueTextVisible},
         {"isVisible", lua_Slider_isVisible},
         {"release", lua_Slider_release},
@@ -2862,41 +2861,6 @@ int lua_Slider_isEnabled(lua_State* state)
     return 0;
 }
 
-int lua_Slider_isInFocus(lua_State* state)
-{
-    // Get the number of parameters.
-    int paramCount = lua_gettop(state);
-
-    // Attempt to match the parameters to a valid binding.
-    switch (paramCount)
-    {
-        case 1:
-        {
-            if ((lua_type(state, 1) == LUA_TUSERDATA))
-            {
-                Slider* instance = getInstance(state);
-                bool result = instance->isInFocus();
-
-                // Push the return value onto the stack.
-                lua_pushboolean(state, result);
-
-                return 1;
-            }
-
-            lua_pushstring(state, "lua_Slider_isInFocus - Failed to match the given parameters to a valid function signature.");
-            lua_error(state);
-            break;
-        }
-        default:
-        {
-            lua_pushstring(state, "Invalid number of parameters (expected 1).");
-            lua_error(state);
-            break;
-        }
-    }
-    return 0;
-}
-
 int lua_Slider_isValueTextVisible(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_Slider.h

@@ -61,7 +61,6 @@ int lua_Slider_getY(lua_State* state);
 int lua_Slider_getZIndex(lua_State* state);
 int lua_Slider_isContainer(lua_State* state);
 int lua_Slider_isEnabled(lua_State* state);
-int lua_Slider_isInFocus(lua_State* state);
 int lua_Slider_isValueTextVisible(lua_State* state);
 int lua_Slider_isVisible(lua_State* state);
 int lua_Slider_release(lua_State* state);

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_TextBox.cpp

@@ -75,7 +75,6 @@ void luaRegister_TextBox()
         {"getZIndex", lua_TextBox_getZIndex},
         {"isContainer", lua_TextBox_isContainer},
         {"isEnabled", lua_TextBox_isEnabled},
-        {"isInFocus", lua_TextBox_isInFocus},
         {"isVisible", lua_TextBox_isVisible},
         {"release", lua_TextBox_release},
         {"removeListener", lua_TextBox_removeListener},
@@ -2674,41 +2673,6 @@ int lua_TextBox_isEnabled(lua_State* state)
     return 0;
 }
 
-int lua_TextBox_isInFocus(lua_State* state)
-{
-    // Get the number of parameters.
-    int paramCount = lua_gettop(state);
-
-    // Attempt to match the parameters to a valid binding.
-    switch (paramCount)
-    {
-        case 1:
-        {
-            if ((lua_type(state, 1) == LUA_TUSERDATA))
-            {
-                TextBox* instance = getInstance(state);
-                bool result = instance->isInFocus();
-
-                // Push the return value onto the stack.
-                lua_pushboolean(state, result);
-
-                return 1;
-            }
-
-            lua_pushstring(state, "lua_TextBox_isInFocus - Failed to match the given parameters to a valid function signature.");
-            lua_error(state);
-            break;
-        }
-        default:
-        {
-            lua_pushstring(state, "Invalid number of parameters (expected 1).");
-            lua_error(state);
-            break;
-        }
-    }
-    return 0;
-}
-
 int lua_TextBox_isVisible(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_TextBox.h

@@ -56,7 +56,6 @@ int lua_TextBox_getY(lua_State* state);
 int lua_TextBox_getZIndex(lua_State* state);
 int lua_TextBox_isContainer(lua_State* state);
 int lua_TextBox_isEnabled(lua_State* state);
-int lua_TextBox_isInFocus(lua_State* state);
 int lua_TextBox_isVisible(lua_State* state);
 int lua_TextBox_release(lua_State* state);
 int lua_TextBox_removeListener(lua_State* state);

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;
 }
 

samples/browser/res/common/forms/formBasicControls.form

@@ -58,6 +58,7 @@ form basicControls
         position = 20, 450
         size = 250, 80
         text = This is a text box.
+		consumeInputEvents = true
     }
 
 	container radioButtonContainer

tools/encoder/src/FBXSceneEncoder.cpp

@@ -365,6 +365,14 @@ void FBXSceneEncoder::loadAnimationChannels(FbxAnimLayer* animLayer, FbxNode* fb
     Matrix matrix;
     double increment = 1000.0 / (double)frameRate;
     int frameCount = (int)ceil((double)(stopTime - startTime) / increment) + 1; // +1 because stop time is inclusive
+
+    // If the animation for this node only has only 1 key frame and it is equal to the node's transform then ignore it.
+    // This is a work around for a bug in the Blender FBX exporter.
+    if (frameCount == 1 && fbxMatrix == fbxNode->EvaluateLocalTransform(0))
+    {
+        return;
+    }
+
     for (int frame = 0; frame < frameCount; ++frame)
     {
         double time = startTime + (frame * (double)increment);

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";
                     }
                 }