Keeping my lua bindings up-to-date.

gameplay/gameplay.vcxproj

@@ -159,6 +159,7 @@
     <ClCompile Include="src\lua\lua_Global.cpp" />
     <ClCompile Include="src\lua\lua_HeightField.cpp" />
     <ClCompile Include="src\lua\lua_Image.cpp" />
+    <ClCompile Include="src\lua\lua_ImageControl.cpp" />
     <ClCompile Include="src\lua\lua_ImageFormat.cpp" />
     <ClCompile Include="src\lua\lua_Joint.cpp" />
     <ClCompile Include="src\lua\lua_Joystick.cpp" />
@@ -241,6 +242,7 @@
     <ClCompile Include="src\lua\lua_Technique.cpp" />
     <ClCompile Include="src\lua\lua_Terrain.cpp" />
     <ClCompile Include="src\lua\lua_TerrainFlags.cpp" />
+    <ClCompile Include="src\lua\lua_TerrainListener.cpp" />
     <ClCompile Include="src\lua\lua_TextBox.cpp" />
     <ClCompile Include="src\lua\lua_Texture.cpp" />
     <ClCompile Include="src\lua\lua_TextureFilter.cpp" />
@@ -437,6 +439,7 @@
     <ClInclude Include="src\lua\lua_Global.h" />
     <ClInclude Include="src\lua\lua_HeightField.h" />
     <ClInclude Include="src\lua\lua_Image.h" />
+    <ClInclude Include="src\lua\lua_ImageControl.h" />
     <ClInclude Include="src\lua\lua_ImageFormat.h" />
     <ClInclude Include="src\lua\lua_Joint.h" />
     <ClInclude Include="src\lua\lua_Joystick.h" />
@@ -519,6 +522,7 @@
     <ClInclude Include="src\lua\lua_Technique.h" />
     <ClInclude Include="src\lua\lua_Terrain.h" />
     <ClInclude Include="src\lua\lua_TerrainFlags.h" />
+    <ClInclude Include="src\lua\lua_TerrainListener.h" />
     <ClInclude Include="src\lua\lua_TextBox.h" />
     <ClInclude Include="src\lua\lua_Texture.h" />
     <ClInclude Include="src\lua\lua_TextureFilter.h" />

gameplay/gameplay.vcxproj.filters

@@ -843,6 +843,12 @@
     <ClCompile Include="src\ImageControl.cpp">
       <Filter>src</Filter>
     </ClCompile>
+    <ClCompile Include="src\lua\lua_ImageControl.cpp">
+      <Filter>src\lua</Filter>
+    </ClCompile>
+    <ClCompile Include="src\lua\lua_TerrainListener.cpp">
+      <Filter>src\lua</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="src\Animation.h">
@@ -1673,6 +1679,12 @@
     <ClInclude Include="src\ImageControl.h">
       <Filter>src</Filter>
     </ClInclude>
+    <ClInclude Include="src\lua\lua_ImageControl.h">
+      <Filter>src\lua</Filter>
+    </ClInclude>
+    <ClInclude Include="src\lua\lua_TerrainListener.h">
+      <Filter>src\lua</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="src\Game.inl">

gameplay/src/lua/lua_Container.cpp

@@ -11,6 +11,7 @@
 #include "Control.h"
 #include "FlowLayout.h"
 #include "Game.h"
+#include "ImageControl.h"
 #include "Joystick.h"
 #include "Label.h"
 #include "Layout.h"

gameplay/src/lua/lua_DepthStencilTarget.cpp

@@ -20,6 +20,7 @@ void luaRegister_DepthStencilTarget()
         {"getId", lua_DepthStencilTarget_getId},
         {"getRefCount", lua_DepthStencilTarget_getRefCount},
         {"getWidth", lua_DepthStencilTarget_getWidth},
+        {"isPacked", lua_DepthStencilTarget_isPacked},
         {"release", lua_DepthStencilTarget_release},
         {NULL, NULL}
     };
@@ -286,6 +287,41 @@ int lua_DepthStencilTarget_getWidth(lua_State* state)
     return 0;
 }
 
+int lua_DepthStencilTarget_isPacked(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))
+            {
+                DepthStencilTarget* instance = getInstance(state);
+                bool result = instance->isPacked();
+
+                // Push the return value onto the stack.
+                lua_pushboolean(state, result);
+
+                return 1;
+            }
+
+            lua_pushstring(state, "lua_DepthStencilTarget_isPacked - 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_DepthStencilTarget_release(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_DepthStencilTarget.h

@@ -12,6 +12,7 @@ int lua_DepthStencilTarget_getHeight(lua_State* state);
 int lua_DepthStencilTarget_getId(lua_State* state);
 int lua_DepthStencilTarget_getRefCount(lua_State* state);
 int lua_DepthStencilTarget_getWidth(lua_State* state);
+int lua_DepthStencilTarget_isPacked(lua_State* state);
 int lua_DepthStencilTarget_release(lua_State* state);
 int lua_DepthStencilTarget_static_create(lua_State* state);
 int lua_DepthStencilTarget_static_getDepthStencilTarget(lua_State* state);

gameplay/src/lua/lua_Form.cpp

@@ -12,6 +12,7 @@
 #include "FlowLayout.h"
 #include "Form.h"
 #include "Game.h"
+#include "ImageControl.h"
 #include "Joystick.h"
 #include "Label.h"
 #include "Layout.h"

gameplay/src/lua/lua_FrameBuffer.cpp

@@ -20,7 +20,9 @@ void luaRegister_FrameBuffer()
         {"getId", lua_FrameBuffer_getId},
         {"getRefCount", lua_FrameBuffer_getRefCount},
         {"getRenderTarget", lua_FrameBuffer_getRenderTarget},
+        {"getRenderTargetCount", lua_FrameBuffer_getRenderTargetCount},
         {"getWidth", lua_FrameBuffer_getWidth},
+        {"isDefault", lua_FrameBuffer_isDefault},
         {"release", lua_FrameBuffer_release},
         {"setDepthStencilTarget", lua_FrameBuffer_setDepthStencilTarget},
         {"setRenderTarget", lua_FrameBuffer_setRenderTarget},
@@ -383,6 +385,41 @@ int lua_FrameBuffer_getRenderTarget(lua_State* state)
     return 0;
 }
 
+int lua_FrameBuffer_getRenderTargetCount(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))
+            {
+                FrameBuffer* instance = getInstance(state);
+                unsigned int result = instance->getRenderTargetCount();
+
+                // Push the return value onto the stack.
+                lua_pushunsigned(state, result);
+
+                return 1;
+            }
+
+            lua_pushstring(state, "lua_FrameBuffer_getRenderTargetCount - 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_FrameBuffer_getWidth(lua_State* state)
 {
     // Get the number of parameters.
@@ -418,6 +455,41 @@ int lua_FrameBuffer_getWidth(lua_State* state)
     return 0;
 }
 
+int lua_FrameBuffer_isDefault(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))
+            {
+                FrameBuffer* instance = getInstance(state);
+                bool result = instance->isDefault();
+
+                // Push the return value onto the stack.
+                lua_pushboolean(state, result);
+
+                return 1;
+            }
+
+            lua_pushstring(state, "lua_FrameBuffer_isDefault - 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_FrameBuffer_release(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_FrameBuffer.h

@@ -13,7 +13,9 @@ int lua_FrameBuffer_getHeight(lua_State* state);
 int lua_FrameBuffer_getId(lua_State* state);
 int lua_FrameBuffer_getRefCount(lua_State* state);
 int lua_FrameBuffer_getRenderTarget(lua_State* state);
+int lua_FrameBuffer_getRenderTargetCount(lua_State* state);
 int lua_FrameBuffer_getWidth(lua_State* state);
+int lua_FrameBuffer_isDefault(lua_State* state);
 int lua_FrameBuffer_release(lua_State* state);
 int lua_FrameBuffer_setDepthStencilTarget(lua_State* state);
 int lua_FrameBuffer_setRenderTarget(lua_State* state);

gameplay/src/lua/lua_Frustum.cpp

@@ -16,9 +16,11 @@ void luaRegister_Frustum()
         {"getBottom", lua_Frustum_getBottom},
         {"getCorners", lua_Frustum_getCorners},
         {"getFar", lua_Frustum_getFar},
+        {"getFarCorners", lua_Frustum_getFarCorners},
         {"getLeft", lua_Frustum_getLeft},
         {"getMatrix", lua_Frustum_getMatrix},
         {"getNear", lua_Frustum_getNear},
+        {"getNearCorners", lua_Frustum_getNearCorners},
         {"getRight", lua_Frustum_getRight},
         {"getTop", lua_Frustum_getTop},
         {"intersects", lua_Frustum_intersects},
@@ -305,6 +307,48 @@ int lua_Frustum_getFar(lua_State* state)
     return 0;
 }
 
+int lua_Frustum_getFarCorners(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 2:
+        {
+            if ((lua_type(state, 1) == LUA_TUSERDATA) &&
+                (lua_type(state, 2) == LUA_TUSERDATA || lua_type(state, 2) == LUA_TTABLE || lua_type(state, 2) == LUA_TNIL))
+            {
+                // Get parameter 1 off the stack.
+                bool param1Valid;
+                gameplay::ScriptUtil::LuaArray<Vector3> param1 = gameplay::ScriptUtil::getObjectPointer<Vector3>(2, "Vector3", false, &param1Valid);
+                if (!param1Valid)
+                {
+                    lua_pushstring(state, "Failed to convert parameter 1 to type 'Vector3'.");
+                    lua_error(state);
+                }
+
+                Frustum* instance = getInstance(state);
+                instance->getFarCorners(param1);
+                
+                return 0;
+            }
+
+            lua_pushstring(state, "lua_Frustum_getFarCorners - Failed to match the given parameters to a valid function signature.");
+            lua_error(state);
+            break;
+        }
+        default:
+        {
+            lua_pushstring(state, "Invalid number of parameters (expected 2).");
+            lua_error(state);
+            break;
+        }
+    }
+    return 0;
+}
+
 int lua_Frustum_getLeft(lua_State* state)
 {
     // Get the number of parameters.
@@ -435,6 +479,48 @@ int lua_Frustum_getNear(lua_State* state)
     return 0;
 }
 
+int lua_Frustum_getNearCorners(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 2:
+        {
+            if ((lua_type(state, 1) == LUA_TUSERDATA) &&
+                (lua_type(state, 2) == LUA_TUSERDATA || lua_type(state, 2) == LUA_TTABLE || lua_type(state, 2) == LUA_TNIL))
+            {
+                // Get parameter 1 off the stack.
+                bool param1Valid;
+                gameplay::ScriptUtil::LuaArray<Vector3> param1 = gameplay::ScriptUtil::getObjectPointer<Vector3>(2, "Vector3", false, &param1Valid);
+                if (!param1Valid)
+                {
+                    lua_pushstring(state, "Failed to convert parameter 1 to type 'Vector3'.");
+                    lua_error(state);
+                }
+
+                Frustum* instance = getInstance(state);
+                instance->getNearCorners(param1);
+                
+                return 0;
+            }
+
+            lua_pushstring(state, "lua_Frustum_getNearCorners - Failed to match the given parameters to a valid function signature.");
+            lua_error(state);
+            break;
+        }
+        default:
+        {
+            lua_pushstring(state, "Invalid number of parameters (expected 2).");
+            lua_error(state);
+            break;
+        }
+    }
+    return 0;
+}
+
 int lua_Frustum_getRight(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_Frustum.h

@@ -10,9 +10,11 @@ int lua_Frustum__init(lua_State* state);
 int lua_Frustum_getBottom(lua_State* state);
 int lua_Frustum_getCorners(lua_State* state);
 int lua_Frustum_getFar(lua_State* state);
+int lua_Frustum_getFarCorners(lua_State* state);
 int lua_Frustum_getLeft(lua_State* state);
 int lua_Frustum_getMatrix(lua_State* state);
 int lua_Frustum_getNear(lua_State* state);
+int lua_Frustum_getNearCorners(lua_State* state);
 int lua_Frustum_getRight(lua_State* state);
 int lua_Frustum_getTop(lua_State* state);
 int lua_Frustum_intersects(lua_State* state);

gameplay/src/lua/lua_Game.cpp

@@ -62,6 +62,7 @@ void luaRegister_Game()
         {"mouseEvent", lua_Game_mouseEvent},
         {"pause", lua_Game_pause},
         {"registerGesture", lua_Game_registerGesture},
+        {"resizeEvent", lua_Game_resizeEvent},
         {"resume", lua_Game_resume},
         {"run", lua_Game_run},
         {"schedule", lua_Game_schedule},
@@ -1743,6 +1744,46 @@ int lua_Game_registerGesture(lua_State* state)
     return 0;
 }
 
+int lua_Game_resizeEvent(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 3:
+        {
+            if ((lua_type(state, 1) == LUA_TUSERDATA) &&
+                lua_type(state, 2) == LUA_TNUMBER &&
+                lua_type(state, 3) == LUA_TNUMBER)
+            {
+                // Get parameter 1 off the stack.
+                unsigned int param1 = (unsigned int)luaL_checkunsigned(state, 2);
+
+                // Get parameter 2 off the stack.
+                unsigned int param2 = (unsigned int)luaL_checkunsigned(state, 3);
+
+                Game* instance = getInstance(state);
+                instance->resizeEvent(param1, param2);
+                
+                return 0;
+            }
+
+            lua_pushstring(state, "lua_Game_resizeEvent - Failed to match the given parameters to a valid function signature.");
+            lua_error(state);
+            break;
+        }
+        default:
+        {
+            lua_pushstring(state, "Invalid number of parameters (expected 3).");
+            lua_error(state);
+            break;
+        }
+    }
+    return 0;
+}
+
 int lua_Game_resume(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_Game.h

@@ -45,6 +45,7 @@ int lua_Game_menuEvent(lua_State* state);
 int lua_Game_mouseEvent(lua_State* state);
 int lua_Game_pause(lua_State* state);
 int lua_Game_registerGesture(lua_State* state);
+int lua_Game_resizeEvent(lua_State* state);
 int lua_Game_resume(lua_State* state);
 int lua_Game_run(lua_State* state);
 int lua_Game_schedule(lua_State* state);

gameplay/src/lua/lua_Global.cpp

@@ -11,6 +11,7 @@ void luaRegister_lua_Global()
     gameplay::ScriptUtil::setGlobalHierarchyPair("AnimationTarget", "Container");
     gameplay::ScriptUtil::setGlobalHierarchyPair("AnimationTarget", "Control");
     gameplay::ScriptUtil::setGlobalHierarchyPair("AnimationTarget", "Form");
+    gameplay::ScriptUtil::setGlobalHierarchyPair("AnimationTarget", "ImageControl");
     gameplay::ScriptUtil::setGlobalHierarchyPair("AnimationTarget", "Joint");
     gameplay::ScriptUtil::setGlobalHierarchyPair("AnimationTarget", "Joystick");
     gameplay::ScriptUtil::setGlobalHierarchyPair("AnimationTarget", "Label");
@@ -27,6 +28,7 @@ void luaRegister_lua_Global()
     gameplay::ScriptUtil::setGlobalHierarchyPair("Control", "CheckBox");
     gameplay::ScriptUtil::setGlobalHierarchyPair("Control", "Container");
     gameplay::ScriptUtil::setGlobalHierarchyPair("Control", "Form");
+    gameplay::ScriptUtil::setGlobalHierarchyPair("Control", "ImageControl");
     gameplay::ScriptUtil::setGlobalHierarchyPair("Control", "Joystick");
     gameplay::ScriptUtil::setGlobalHierarchyPair("Control", "Label");
     gameplay::ScriptUtil::setGlobalHierarchyPair("Control", "RadioButton");
@@ -76,6 +78,7 @@ void luaRegister_lua_Global()
     gameplay::ScriptUtil::setGlobalHierarchyPair("Ref", "FrameBuffer");
     gameplay::ScriptUtil::setGlobalHierarchyPair("Ref", "HeightField");
     gameplay::ScriptUtil::setGlobalHierarchyPair("Ref", "Image");
+    gameplay::ScriptUtil::setGlobalHierarchyPair("Ref", "ImageControl");
     gameplay::ScriptUtil::setGlobalHierarchyPair("Ref", "Joint");
     gameplay::ScriptUtil::setGlobalHierarchyPair("Ref", "Joystick");
     gameplay::ScriptUtil::setGlobalHierarchyPair("Ref", "Label");
@@ -114,6 +117,7 @@ void luaRegister_lua_Global()
     gameplay::ScriptUtil::setGlobalHierarchyPair("ScriptTarget", "Container");
     gameplay::ScriptUtil::setGlobalHierarchyPair("ScriptTarget", "Control");
     gameplay::ScriptUtil::setGlobalHierarchyPair("ScriptTarget", "Form");
+    gameplay::ScriptUtil::setGlobalHierarchyPair("ScriptTarget", "ImageControl");
     gameplay::ScriptUtil::setGlobalHierarchyPair("ScriptTarget", "Joint");
     gameplay::ScriptUtil::setGlobalHierarchyPair("ScriptTarget", "Joystick");
     gameplay::ScriptUtil::setGlobalHierarchyPair("ScriptTarget", "Label");
@@ -377,9 +381,9 @@ void luaRegister_lua_Global()
         scopePath.push_back("Gamepad");
         gameplay::ScriptUtil::registerConstantString("CONNECTED_EVENT", "CONNECTED_EVENT", scopePath);
         gameplay::ScriptUtil::registerConstantString("DISCONNECTED_EVENT", "DISCONNECTED_EVENT", scopePath);
-        ScriptUtil::registerConstantString("BUTTON_EVENT", "BUTTON_EVENT", scopePath);
-        ScriptUtil::registerConstantString("JOYSTICK_EVENT", "JOYSTICK_EVENT", scopePath);
-        ScriptUtil::registerConstantString("TRIGGER_EVENT", "TRIGGER_EVENT", scopePath);
+        gameplay::ScriptUtil::registerConstantString("BUTTON_EVENT", "BUTTON_EVENT", scopePath);
+        gameplay::ScriptUtil::registerConstantString("JOYSTICK_EVENT", "JOYSTICK_EVENT", scopePath);
+        gameplay::ScriptUtil::registerConstantString("TRIGGER_EVENT", "TRIGGER_EVENT", scopePath);
     }
 
     // Register enumeration Gesture::GestureEvent.

gameplay/src/lua/lua_Light.cpp

@@ -35,6 +35,7 @@ void luaRegister_Light()
     };
     const luaL_Reg lua_statics[] = 
     {
+        {"create", lua_Light_static_create},
         {"createDirectional", lua_Light_static_createDirectional},
         {"createPoint", lua_Light_static_createPoint},
         {"createSpot", lua_Light_static_createSpot},
@@ -701,6 +702,58 @@ int lua_Light_setRange(lua_State* state)
     return 0;
 }
 
+int lua_Light_static_create(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 || lua_type(state, 1) == LUA_TTABLE || lua_type(state, 1) == LUA_TNIL))
+            {
+                // Get parameter 1 off the stack.
+                bool param1Valid;
+                gameplay::ScriptUtil::LuaArray<Properties> param1 = gameplay::ScriptUtil::getObjectPointer<Properties>(1, "Properties", false, &param1Valid);
+                if (!param1Valid)
+                {
+                    lua_pushstring(state, "Failed to convert parameter 1 to type 'Properties'.");
+                    lua_error(state);
+                }
+
+                void* returnPtr = (void*)Light::create(param1);
+                if (returnPtr)
+                {
+                    gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject));
+                    object->instance = returnPtr;
+                    object->owns = false;
+                    luaL_getmetatable(state, "Light");
+                    lua_setmetatable(state, -2);
+                }
+                else
+                {
+                    lua_pushnil(state);
+                }
+
+                return 1;
+            }
+
+            lua_pushstring(state, "lua_Light_static_create - 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_Light_static_createDirectional(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_Light.h

@@ -22,6 +22,7 @@ int lua_Light_setColor(lua_State* state);
 int lua_Light_setInnerAngle(lua_State* state);
 int lua_Light_setOuterAngle(lua_State* state);
 int lua_Light_setRange(lua_State* state);
+int lua_Light_static_create(lua_State* state);
 int lua_Light_static_createDirectional(lua_State* state);
 int lua_Light_static_createPoint(lua_State* state);
 int lua_Light_static_createSpot(lua_State* state);

gameplay/src/lua/lua_Material.cpp

@@ -25,6 +25,7 @@ void luaRegister_Material()
     const luaL_Reg lua_members[] = 
     {
         {"addRef", lua_Material_addRef},
+        {"clearParameter", lua_Material_clearParameter},
         {"getParameter", lua_Material_getParameter},
         {"getRefCount", lua_Material_getRefCount},
         {"getStateBlock", lua_Material_getStateBlock},
@@ -124,6 +125,42 @@ int lua_Material_addRef(lua_State* state)
     return 0;
 }
 
+int lua_Material_clearParameter(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 2:
+        {
+            if ((lua_type(state, 1) == LUA_TUSERDATA) &&
+                (lua_type(state, 2) == LUA_TSTRING || lua_type(state, 2) == LUA_TNIL))
+            {
+                // Get parameter 1 off the stack.
+                const char* param1 = gameplay::ScriptUtil::getString(2, false);
+
+                Material* instance = getInstance(state);
+                instance->clearParameter(param1);
+                
+                return 0;
+            }
+
+            lua_pushstring(state, "lua_Material_clearParameter - Failed to match the given parameters to a valid function signature.");
+            lua_error(state);
+            break;
+        }
+        default:
+        {
+            lua_pushstring(state, "Invalid number of parameters (expected 2).");
+            lua_error(state);
+            break;
+        }
+    }
+    return 0;
+}
+
 int lua_Material_getParameter(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_Material.h

@@ -7,6 +7,7 @@ namespace gameplay
 // Lua bindings for Material.
 int lua_Material__gc(lua_State* state);
 int lua_Material_addRef(lua_State* state);
+int lua_Material_clearParameter(lua_State* state);
 int lua_Material_getParameter(lua_State* state);
 int lua_Material_getRefCount(lua_State* state);
 int lua_Material_getStateBlock(lua_State* state);

gameplay/src/lua/lua_Pass.cpp

@@ -23,6 +23,7 @@ void luaRegister_Pass()
     {
         {"addRef", lua_Pass_addRef},
         {"bind", lua_Pass_bind},
+        {"clearParameter", lua_Pass_clearParameter},
         {"getEffect", lua_Pass_getEffect},
         {"getId", lua_Pass_getId},
         {"getParameter", lua_Pass_getParameter},
@@ -151,6 +152,42 @@ int lua_Pass_bind(lua_State* state)
     return 0;
 }
 
+int lua_Pass_clearParameter(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 2:
+        {
+            if ((lua_type(state, 1) == LUA_TUSERDATA) &&
+                (lua_type(state, 2) == LUA_TSTRING || lua_type(state, 2) == LUA_TNIL))
+            {
+                // Get parameter 1 off the stack.
+                const char* param1 = gameplay::ScriptUtil::getString(2, false);
+
+                Pass* instance = getInstance(state);
+                instance->clearParameter(param1);
+                
+                return 0;
+            }
+
+            lua_pushstring(state, "lua_Pass_clearParameter - Failed to match the given parameters to a valid function signature.");
+            lua_error(state);
+            break;
+        }
+        default:
+        {
+            lua_pushstring(state, "Invalid number of parameters (expected 2).");
+            lua_error(state);
+            break;
+        }
+    }
+    return 0;
+}
+
 int lua_Pass_getEffect(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_Pass.h

@@ -8,6 +8,7 @@ namespace gameplay
 int lua_Pass__gc(lua_State* state);
 int lua_Pass_addRef(lua_State* state);
 int lua_Pass_bind(lua_State* state);
+int lua_Pass_clearParameter(lua_State* state);
 int lua_Pass_getEffect(lua_State* state);
 int lua_Pass_getId(lua_State* state);
 int lua_Pass_getParameter(lua_State* state);

gameplay/src/lua/lua_Platform.cpp

@@ -1,7 +1,11 @@
 #include "Base.h"
 #include "ScriptController.h"
 #include "lua_Platform.h"
+#include "Base.h"
+#include "Form.h"
+#include "Game.h"
 #include "Platform.h"
+#include "ScriptController.h"
 
 namespace gameplay
 {

gameplay/src/lua/lua_RenderState.cpp

@@ -21,6 +21,7 @@ void luaRegister_RenderState()
     const luaL_Reg lua_members[] = 
     {
         {"addRef", lua_RenderState_addRef},
+        {"clearParameter", lua_RenderState_clearParameter},
         {"getParameter", lua_RenderState_getParameter},
         {"getRefCount", lua_RenderState_getRefCount},
         {"getStateBlock", lua_RenderState_getStateBlock},
@@ -112,6 +113,42 @@ int lua_RenderState_addRef(lua_State* state)
     return 0;
 }
 
+int lua_RenderState_clearParameter(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 2:
+        {
+            if ((lua_type(state, 1) == LUA_TUSERDATA) &&
+                (lua_type(state, 2) == LUA_TSTRING || lua_type(state, 2) == LUA_TNIL))
+            {
+                // Get parameter 1 off the stack.
+                const char* param1 = gameplay::ScriptUtil::getString(2, false);
+
+                RenderState* instance = getInstance(state);
+                instance->clearParameter(param1);
+                
+                return 0;
+            }
+
+            lua_pushstring(state, "lua_RenderState_clearParameter - Failed to match the given parameters to a valid function signature.");
+            lua_error(state);
+            break;
+        }
+        default:
+        {
+            lua_pushstring(state, "Invalid number of parameters (expected 2).");
+            lua_error(state);
+            break;
+        }
+    }
+    return 0;
+}
+
 int lua_RenderState_getParameter(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_RenderState.h

@@ -7,6 +7,7 @@ namespace gameplay
 // Lua bindings for RenderState.
 int lua_RenderState__gc(lua_State* state);
 int lua_RenderState_addRef(lua_State* state);
+int lua_RenderState_clearParameter(lua_State* state);
 int lua_RenderState_getParameter(lua_State* state);
 int lua_RenderState_getRefCount(lua_State* state);
 int lua_RenderState_getStateBlock(lua_State* state);

gameplay/src/lua/lua_Scene.cpp

@@ -3,6 +3,7 @@
 #include "lua_Scene.h"
 #include "AudioListener.h"
 #include "Base.h"
+#include "Bundle.h"
 #include "Game.h"
 #include "Joint.h"
 #include "MeshSkin.h"

gameplay/src/lua/lua_SpriteBatch.cpp

@@ -3,6 +3,7 @@
 #include "lua_SpriteBatch.h"
 #include "Base.h"
 #include "Game.h"
+#include "Material.h"
 #include "SpriteBatch.h"
 
 namespace gameplay

gameplay/src/lua/lua_Technique.cpp

@@ -22,6 +22,7 @@ void luaRegister_Technique()
     const luaL_Reg lua_members[] = 
     {
         {"addRef", lua_Technique_addRef},
+        {"clearParameter", lua_Technique_clearParameter},
         {"getId", lua_Technique_getId},
         {"getParameter", lua_Technique_getParameter},
         {"getPass", lua_Technique_getPass},
@@ -117,6 +118,42 @@ int lua_Technique_addRef(lua_State* state)
     return 0;
 }
 
+int lua_Technique_clearParameter(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 2:
+        {
+            if ((lua_type(state, 1) == LUA_TUSERDATA) &&
+                (lua_type(state, 2) == LUA_TSTRING || lua_type(state, 2) == LUA_TNIL))
+            {
+                // Get parameter 1 off the stack.
+                const char* param1 = gameplay::ScriptUtil::getString(2, false);
+
+                Technique* instance = getInstance(state);
+                instance->clearParameter(param1);
+                
+                return 0;
+            }
+
+            lua_pushstring(state, "lua_Technique_clearParameter - Failed to match the given parameters to a valid function signature.");
+            lua_error(state);
+            break;
+        }
+        default:
+        {
+            lua_pushstring(state, "Invalid number of parameters (expected 2).");
+            lua_error(state);
+            break;
+        }
+    }
+    return 0;
+}
+
 int lua_Technique_getId(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_Technique.h

@@ -7,6 +7,7 @@ namespace gameplay
 // Lua bindings for Technique.
 int lua_Technique__gc(lua_State* state);
 int lua_Technique_addRef(lua_State* state);
+int lua_Technique_clearParameter(lua_State* state);
 int lua_Technique_getId(lua_State* state);
 int lua_Technique_getParameter(lua_State* state);
 int lua_Technique_getPass(lua_State* state);

gameplay/src/lua/lua_Terrain.cpp

@@ -23,18 +23,25 @@ void luaRegister_Terrain()
 {
     const luaL_Reg lua_members[] = 
     {
+        {"addListener", lua_Terrain_addListener},
         {"addRef", lua_Terrain_addRef},
         {"draw", lua_Terrain_draw},
         {"getBoundingBox", lua_Terrain_getBoundingBox},
         {"getHeight", lua_Terrain_getHeight},
+        {"getInverseWorldMatrix", lua_Terrain_getInverseWorldMatrix},
         {"getNode", lua_Terrain_getNode},
+        {"getNormalMatrix", lua_Terrain_getNormalMatrix},
         {"getPatchCount", lua_Terrain_getPatchCount},
         {"getRefCount", lua_Terrain_getRefCount},
         {"getTriangleCount", lua_Terrain_getTriangleCount},
         {"getVisiblePatchCount", lua_Terrain_getVisiblePatchCount},
         {"getVisibleTriangleCount", lua_Terrain_getVisibleTriangleCount},
+        {"getWorldMatrix", lua_Terrain_getWorldMatrix},
+        {"getWorldViewMatrix", lua_Terrain_getWorldViewMatrix},
+        {"getWorldViewProjectionMatrix", lua_Terrain_getWorldViewProjectionMatrix},
         {"isFlagSet", lua_Terrain_isFlagSet},
         {"release", lua_Terrain_release},
+        {"removeListener", lua_Terrain_removeListener},
         {"setFlag", lua_Terrain_setFlag},
         {"transformChanged", lua_Terrain_transformChanged},
         {NULL, NULL}
@@ -94,6 +101,48 @@ int lua_Terrain__gc(lua_State* state)
     return 0;
 }
 
+int lua_Terrain_addListener(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 2:
+        {
+            if ((lua_type(state, 1) == LUA_TUSERDATA) &&
+                (lua_type(state, 2) == LUA_TUSERDATA || lua_type(state, 2) == LUA_TTABLE || lua_type(state, 2) == LUA_TNIL))
+            {
+                // Get parameter 1 off the stack.
+                bool param1Valid;
+                gameplay::ScriptUtil::LuaArray<Terrain::Listener> param1 = gameplay::ScriptUtil::getObjectPointer<Terrain::Listener>(2, "TerrainListener", false, &param1Valid);
+                if (!param1Valid)
+                {
+                    lua_pushstring(state, "Failed to convert parameter 1 to type 'Terrain::Listener'.");
+                    lua_error(state);
+                }
+
+                Terrain* instance = getInstance(state);
+                instance->addListener(param1);
+                
+                return 0;
+            }
+
+            lua_pushstring(state, "lua_Terrain_addListener - Failed to match the given parameters to a valid function signature.");
+            lua_error(state);
+            break;
+        }
+        default:
+        {
+            lua_pushstring(state, "Invalid number of parameters (expected 2).");
+            lua_error(state);
+            break;
+        }
+    }
+    return 0;
+}
+
 int lua_Terrain_addRef(lua_State* state)
 {
     // Get the number of parameters.
@@ -263,6 +312,50 @@ int lua_Terrain_getHeight(lua_State* state)
     return 0;
 }
 
+int lua_Terrain_getInverseWorldMatrix(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))
+            {
+                Terrain* instance = getInstance(state);
+                void* returnPtr = (void*)&(instance->getInverseWorldMatrix());
+                if (returnPtr)
+                {
+                    gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject));
+                    object->instance = returnPtr;
+                    object->owns = false;
+                    luaL_getmetatable(state, "Matrix");
+                    lua_setmetatable(state, -2);
+                }
+                else
+                {
+                    lua_pushnil(state);
+                }
+
+                return 1;
+            }
+
+            lua_pushstring(state, "lua_Terrain_getInverseWorldMatrix - 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_Terrain_getNode(lua_State* state)
 {
     // Get the number of parameters.
@@ -307,6 +400,50 @@ int lua_Terrain_getNode(lua_State* state)
     return 0;
 }
 
+int lua_Terrain_getNormalMatrix(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))
+            {
+                Terrain* instance = getInstance(state);
+                void* returnPtr = (void*)&(instance->getNormalMatrix());
+                if (returnPtr)
+                {
+                    gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject));
+                    object->instance = returnPtr;
+                    object->owns = false;
+                    luaL_getmetatable(state, "Matrix");
+                    lua_setmetatable(state, -2);
+                }
+                else
+                {
+                    lua_pushnil(state);
+                }
+
+                return 1;
+            }
+
+            lua_pushstring(state, "lua_Terrain_getNormalMatrix - 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_Terrain_getPatchCount(lua_State* state)
 {
     // Get the number of parameters.
@@ -482,6 +619,138 @@ int lua_Terrain_getVisibleTriangleCount(lua_State* state)
     return 0;
 }
 
+int lua_Terrain_getWorldMatrix(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))
+            {
+                Terrain* instance = getInstance(state);
+                void* returnPtr = (void*)&(instance->getWorldMatrix());
+                if (returnPtr)
+                {
+                    gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject));
+                    object->instance = returnPtr;
+                    object->owns = false;
+                    luaL_getmetatable(state, "Matrix");
+                    lua_setmetatable(state, -2);
+                }
+                else
+                {
+                    lua_pushnil(state);
+                }
+
+                return 1;
+            }
+
+            lua_pushstring(state, "lua_Terrain_getWorldMatrix - 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_Terrain_getWorldViewMatrix(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))
+            {
+                Terrain* instance = getInstance(state);
+                void* returnPtr = (void*)&(instance->getWorldViewMatrix());
+                if (returnPtr)
+                {
+                    gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject));
+                    object->instance = returnPtr;
+                    object->owns = false;
+                    luaL_getmetatable(state, "Matrix");
+                    lua_setmetatable(state, -2);
+                }
+                else
+                {
+                    lua_pushnil(state);
+                }
+
+                return 1;
+            }
+
+            lua_pushstring(state, "lua_Terrain_getWorldViewMatrix - 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_Terrain_getWorldViewProjectionMatrix(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))
+            {
+                Terrain* instance = getInstance(state);
+                void* returnPtr = (void*)&(instance->getWorldViewProjectionMatrix());
+                if (returnPtr)
+                {
+                    gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject));
+                    object->instance = returnPtr;
+                    object->owns = false;
+                    luaL_getmetatable(state, "Matrix");
+                    lua_setmetatable(state, -2);
+                }
+                else
+                {
+                    lua_pushnil(state);
+                }
+
+                return 1;
+            }
+
+            lua_pushstring(state, "lua_Terrain_getWorldViewProjectionMatrix - 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_Terrain_isFlagSet(lua_State* state)
 {
     // Get the number of parameters.
@@ -553,6 +822,48 @@ int lua_Terrain_release(lua_State* state)
     return 0;
 }
 
+int lua_Terrain_removeListener(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 2:
+        {
+            if ((lua_type(state, 1) == LUA_TUSERDATA) &&
+                (lua_type(state, 2) == LUA_TUSERDATA || lua_type(state, 2) == LUA_TTABLE || lua_type(state, 2) == LUA_TNIL))
+            {
+                // Get parameter 1 off the stack.
+                bool param1Valid;
+                gameplay::ScriptUtil::LuaArray<Terrain::Listener> param1 = gameplay::ScriptUtil::getObjectPointer<Terrain::Listener>(2, "TerrainListener", false, &param1Valid);
+                if (!param1Valid)
+                {
+                    lua_pushstring(state, "Failed to convert parameter 1 to type 'Terrain::Listener'.");
+                    lua_error(state);
+                }
+
+                Terrain* instance = getInstance(state);
+                instance->removeListener(param1);
+                
+                return 0;
+            }
+
+            lua_pushstring(state, "lua_Terrain_removeListener - Failed to match the given parameters to a valid function signature.");
+            lua_error(state);
+            break;
+        }
+        default:
+        {
+            lua_pushstring(state, "Invalid number of parameters (expected 2).");
+            lua_error(state);
+            break;
+        }
+    }
+    return 0;
+}
+
 int lua_Terrain_setFlag(lua_State* state)
 {
     // Get the number of parameters.

gameplay/src/lua/lua_Terrain.h

@@ -1,29 +1,36 @@
-#ifndef LUA_TERRAIN_H_
-#define LUA_TERRAIN_H_
-
-namespace gameplay
-{
-
-// Lua bindings for Terrain.
-int lua_Terrain__gc(lua_State* state);
-int lua_Terrain_addRef(lua_State* state);
-int lua_Terrain_draw(lua_State* state);
-int lua_Terrain_getBoundingBox(lua_State* state);
-int lua_Terrain_getHeight(lua_State* state);
-int lua_Terrain_getNode(lua_State* state);
-int lua_Terrain_getPatchCount(lua_State* state);
-int lua_Terrain_getRefCount(lua_State* state);
-int lua_Terrain_getTriangleCount(lua_State* state);
-int lua_Terrain_getVisiblePatchCount(lua_State* state);
-int lua_Terrain_getVisibleTriangleCount(lua_State* state);
-int lua_Terrain_isFlagSet(lua_State* state);
-int lua_Terrain_release(lua_State* state);
-int lua_Terrain_setFlag(lua_State* state);
-int lua_Terrain_static_create(lua_State* state);
-int lua_Terrain_transformChanged(lua_State* state);
-
-void luaRegister_Terrain();
-
-}
-
-#endif
+#ifndef LUA_TERRAIN_H_
+#define LUA_TERRAIN_H_
+
+namespace gameplay
+{
+
+// Lua bindings for Terrain.
+int lua_Terrain__gc(lua_State* state);
+int lua_Terrain_addListener(lua_State* state);
+int lua_Terrain_addRef(lua_State* state);
+int lua_Terrain_draw(lua_State* state);
+int lua_Terrain_getBoundingBox(lua_State* state);
+int lua_Terrain_getHeight(lua_State* state);
+int lua_Terrain_getInverseWorldMatrix(lua_State* state);
+int lua_Terrain_getNode(lua_State* state);
+int lua_Terrain_getNormalMatrix(lua_State* state);
+int lua_Terrain_getPatchCount(lua_State* state);
+int lua_Terrain_getRefCount(lua_State* state);
+int lua_Terrain_getTriangleCount(lua_State* state);
+int lua_Terrain_getVisiblePatchCount(lua_State* state);
+int lua_Terrain_getVisibleTriangleCount(lua_State* state);
+int lua_Terrain_getWorldMatrix(lua_State* state);
+int lua_Terrain_getWorldViewMatrix(lua_State* state);
+int lua_Terrain_getWorldViewProjectionMatrix(lua_State* state);
+int lua_Terrain_isFlagSet(lua_State* state);
+int lua_Terrain_release(lua_State* state);
+int lua_Terrain_removeListener(lua_State* state);
+int lua_Terrain_setFlag(lua_State* state);
+int lua_Terrain_static_create(lua_State* state);
+int lua_Terrain_transformChanged(lua_State* state);
+
+void luaRegister_Terrain();
+
+}
+
+#endif

gameplay/src/lua/lua_ThemeUVs.cpp

@@ -23,6 +23,7 @@ void luaRegister_ThemeUVs()
     const luaL_Reg lua_statics[] = 
     {
         {"empty", lua_ThemeUVs_static_empty},
+        {"full", lua_ThemeUVs_static_full},
         {NULL, NULL}
     };
     std::vector<std::string> scopePath;
@@ -193,6 +194,43 @@ int lua_ThemeUVs_static_empty(lua_State* state)
     return 0;
 }
 
+int lua_ThemeUVs_static_full(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 0:
+        {
+            void* returnPtr = (void*)&(Theme::UVs::full());
+            if (returnPtr)
+            {
+                gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject));
+                object->instance = returnPtr;
+                object->owns = false;
+                luaL_getmetatable(state, "ThemeUVs");
+                lua_setmetatable(state, -2);
+            }
+            else
+            {
+                lua_pushnil(state);
+            }
+
+            return 1;
+            break;
+        }
+        default:
+        {
+            lua_pushstring(state, "Invalid number of parameters (expected 0).");
+            lua_error(state);
+            break;
+        }
+    }
+    return 0;
+}
+
 int lua_ThemeUVs_u1(lua_State* state)
 {
     // Validate the number of parameters.

gameplay/src/lua/lua_ThemeUVs.h

@@ -8,6 +8,7 @@ namespace gameplay
 int lua_ThemeUVs__gc(lua_State* state);
 int lua_ThemeUVs__init(lua_State* state);
 int lua_ThemeUVs_static_empty(lua_State* state);
+int lua_ThemeUVs_static_full(lua_State* state);
 int lua_ThemeUVs_u1(lua_State* state);
 int lua_ThemeUVs_u2(lua_State* state);
 int lua_ThemeUVs_v1(lua_State* state);

gameplay/src/lua/lua_all_bindings.cpp

@@ -48,6 +48,7 @@ void lua_RegisterAllBindings()
     luaRegister_Gesture();
     luaRegister_HeightField();
     luaRegister_Image();
+    luaRegister_ImageControl();
     luaRegister_Joint();
     luaRegister_Joystick();
     luaRegister_Keyboard();
@@ -109,6 +110,7 @@ void lua_RegisterAllBindings()
     luaRegister_SpriteBatch();
     luaRegister_Technique();
     luaRegister_Terrain();
+    luaRegister_TerrainListener();
     luaRegister_TextBox();
     luaRegister_Texture();
     luaRegister_TextureSampler();

gameplay/src/lua/lua_all_bindings.h

@@ -43,6 +43,7 @@
 #include "lua_Gesture.h"
 #include "lua_HeightField.h"
 #include "lua_Image.h"
+#include "lua_ImageControl.h"
 #include "lua_Joint.h"
 #include "lua_Joystick.h"
 #include "lua_Keyboard.h"
@@ -104,6 +105,7 @@
 #include "lua_SpriteBatch.h"
 #include "lua_Technique.h"
 #include "lua_Terrain.h"
+#include "lua_TerrainListener.h"
 #include "lua_TextBox.h"
 #include "lua_Texture.h"
 #include "lua_TextureSampler.h"