Changed Input.h to separate out Keyboard and Touch into seperate headers.

Updated interfaces for Game input handling and added accellerometer api here too.

gameplay-encoder/gameplay-encoder.vcxproj

@@ -145,16 +145,16 @@
       </PrecompiledHeader>
       <WarningLevel>Level4</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;NO_BOOST;NO_ZAE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>../external-deps/freetype2/include;../external-deps/collada-dom/include;../external-deps/collada-dom/include/1.4;../external-deps/libpng/include;../external-deps/zlib/include</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;NO_BOOST;NO_ZAE;USE_FBX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>../external-deps/freetype2/include;../external-deps/collada-dom/include;../external-deps/collada-dom/include/1.4;../external-deps/libpng/include;../external-deps/zlib/include;C:/Program Files/Autodesk/FBX/FbxSdk/2012.2/include</AdditionalIncludeDirectories>
       <DisableLanguageExtensions>
       </DisableLanguageExtensions>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalLibraryDirectories>../external-deps/freetype2/lib/win32;../external-deps/collada-dom/lib/win32;../external-deps/libpng/lib/win32;../external-deps/zlib/lib/win32</AdditionalLibraryDirectories>
-      <AdditionalDependencies>freetype245.lib;libcollada14dom22-d.lib;libpng14.lib;zlib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>../external-deps/freetype2/lib/win32;../external-deps/collada-dom/lib/win32;../external-deps/libpng/lib/win32;../external-deps/zlib/lib/win32;C:/Program Files/Autodesk/FBX/FbxSdk/2012.2/lib/vs2010/x86</AdditionalLibraryDirectories>
+      <AdditionalDependencies>freetype245.lib;libcollada14dom22-d.lib;libpng14.lib;zlib.lib;fbxsdk-2012.2-mdd.lib;wininet.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <IgnoreSpecificDefaultLibraries>MSVCRT</IgnoreSpecificDefaultLibraries>
     </Link>
     <PostBuildEvent>

gameplay/gameplay.vcxproj

@@ -39,7 +39,6 @@
     <ClCompile Include="src\gameplay-main-qnx.cpp" />
     <ClCompile Include="src\gameplay-main-win32.cpp" />
     <ClCompile Include="src\Image.cpp" />
-    <ClCompile Include="src\Input.cpp" />
     <ClCompile Include="src\Joint.cpp" />
     <ClCompile Include="src\Light.cpp" />
     <ClCompile Include="src\Material.cpp" />
@@ -110,8 +109,8 @@
     <ClInclude Include="src\Game.h" />
     <ClInclude Include="src\gameplay.h" />
     <ClInclude Include="src\Image.h" />
-    <ClInclude Include="src\Input.h" />
     <ClInclude Include="src\Joint.h" />
+    <ClInclude Include="src\Keyboard.h" />
     <ClInclude Include="src\Light.h" />
     <ClInclude Include="src\Material.h" />
     <ClInclude Include="src\Pass.h" />
@@ -147,6 +146,7 @@
     <ClInclude Include="src\SpriteBatch.h" />
     <ClInclude Include="src\Technique.h" />
     <ClInclude Include="src\Texture.h" />
+    <ClInclude Include="src\Touch.h" />
     <ClInclude Include="src\Transform.h" />
     <ClInclude Include="src\Vector2.h" />
     <ClInclude Include="src\Vector3.h" />

gameplay/gameplay.vcxproj.filters

@@ -54,9 +54,6 @@
     <ClCompile Include="src\Game.cpp">
       <Filter>src</Filter>
     </ClCompile>
-    <ClCompile Include="src\Input.cpp">
-      <Filter>src</Filter>
-    </ClCompile>
     <ClCompile Include="src\Light.cpp">
       <Filter>src</Filter>
     </ClCompile>
@@ -272,9 +269,6 @@
     <ClInclude Include="src\gameplay.h">
       <Filter>src</Filter>
     </ClInclude>
-    <ClInclude Include="src\Input.h">
-      <Filter>src</Filter>
-    </ClInclude>
     <ClInclude Include="src\Light.h">
       <Filter>src</Filter>
     </ClInclude>
@@ -428,6 +422,12 @@
     <ClInclude Include="src\DepthStencilTarget.h">
       <Filter>src</Filter>
     </ClInclude>
+    <ClInclude Include="src\Keyboard.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="src\Touch.h">
+      <Filter>src</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="res\shaders\bumped-specular.vsh">

gameplay/src/Game.cpp

@@ -237,15 +237,11 @@ void Game::menu()
 {
 }
 
-void Game::keyChar(char key)
+void Game::keyEvent(Keyboard::KeyEvent evt, int key)
 {
 }
 
-void Game::keyPress(int key, int keyEvent)
-{
-}
-
-void Game::touch(int x, int y, int touchEvent)
+void Game::touchEvent(Touch::TouchEvent evt, int x, int y, unsigned int contactIndex)
 {
 }
 

gameplay/src/Game.h

@@ -1,7 +1,8 @@
 #ifndef GAME_H_
 #define GAME_H_
 
-#include "Input.h"
+#include "Keyboard.h"
+#include "Touch.h"
 #include "AudioController.h"
 #include "AnimationController.h"
 #include "PhysicsController.h"
@@ -185,33 +186,45 @@ public:
     virtual void menu();
 
     /**
-     * Input callback on keyChar events.
+     * Keyboard callback on keyPress events.
      *
-     * @param key The key code pressed.
+     * @param evt The key event that occured.
+     * @param key The key code that was pressed, released or repeated.
+     * 
+     * @see Keyboard::Key
      */
-    virtual void keyChar(char key);
+    virtual void keyEvent(Keyboard::KeyEvent evt, int key);
 
     /**
-     * Input callback on keyPress events.
+     * Touch callback on touch events.
      *
-     * @param key The key code pressed.
-     * @param keyEvent The key event that occured.
-     * 
-     * @see Input::Key
-     * @see Input::KeyEvent
+     * @param evt The touch event that occurred.
+     *
+     * @see Touch::TouchEvent
      */
-    virtual void keyPress(int key, int keyEvent);
+    virtual void touchEvent(Touch::TouchEvent evt, int x, int y, unsigned int contactIndex);
 
     /**
-     * Input callback on touch events.
+     * Sets muli-touch is to be enabled/disabled. Default is disabled.
      *
-     * @param x The x position of the touch.
-     * @param y The y position of the touch.
-     * @param touchEvent The touch event that occurred.
-     * 
-     * @see Input::TouchEvent
+     * @param enabled true sets multi-touch is enabled, false to be disabled.
+     */
+    inline void setMultiTouch(bool enabled);
+
+    /**
+     * Is multi-touch mode enabled.
+     *
+     * @return true is multi-touch is enabled.
+     */
+    inline bool isMultiTouch() const;
+
+    /**
+     * Gets the current accelerometer values.
+     *
+     * @param pitch The pitch angle returned (in degrees). If NULL then not returned.
+     * @param roll The roll angle returned (in degrees). If NULL then not returned.
      */
-    virtual void touch(int x, int y, int touchEvent);
+    inline void getAccelerometerValues(float* pitch, float* roll);
 
 protected:
 

gameplay/src/Game.inl

@@ -42,8 +42,21 @@ inline PhysicsController* Game::getPhysicsController() const
 template <class T>
 void  Game::renderOnce(T* instance, void (T::*method)(void*), void* cookie)
 {
-    (instance->*method)(cookie);
-    Platform::swapBuffers();
+}
+
+inline void Game::setMultiTouch(bool enabled)
+{
+    Platform::setMultiTouch(enabled);
+}
+
+inline bool isMultiTouch()
+{
+    return Platform::isMultiTouch();
+}
+
+inline void Game::getAccelerometerValues(float* pitch, float* roll)
+{
+    Platform::getAccelerometerValues(pitch, roll);
 }
 
 }

gameplay/src/Input.cpp

@@ -1,23 +0,0 @@
-#include "Base.h"
-#include "Input.h"
-#include "Platform.h"
-#include "Game.h"
-
-namespace gameplay
-{
-
-Input::Input()
-{
-}
-
-bool Input::isAccelerometerSupported()
-{
-    return Platform::isAccelerometerSupported();
-}
-
-void Input::getAccelerometerPitchAndRoll(float* pitch, float* roll)
-{
-    Platform::getAccelerometerPitchAndRoll(pitch, roll);
-}
-
-}

gameplay/src/Input.h → gameplay/src/Keyboard.h

@@ -1,33 +1,26 @@
-#ifndef INPUT_H_
-#define INPUT_H_
+
+#ifndef KEYBOARD_H_
+#define KEYBOARD_H_
 
 namespace gameplay
 {
 
 /**
- * Defines an input class for requesting input.
+ * Keyboard key event and key definitions.
  */
-class Input
+class Keyboard
 {
-public:
+    friend class Platform;
 
-    /**
-     * The touch event.
-     */
-    enum TouchEvent
-    {
-        TOUCHEVENT_PRESS,
-        TOUCHEVENT_RELEASE,
-        TOUCHEVENT_MOVE
-    };
+public:
 
-    /**
-     * The key event.
+   /**
+     * The keyboard event.
      */
     enum KeyEvent
     {
-        KEYEVENT_DOWN,
-        KEYEVENT_UP
+        KEY_PRESS,
+        KEY_RELEASE
     };
 
     /**
@@ -192,27 +185,12 @@ public:
         KEY_TILDE
     };
 
-    /**
-     * Indicates if the game device supports accelerometer.
-     * 
-     * @return true if the accelerometer is supported; false otherwise.
-     */
-    static bool isAccelerometerSupported();
-
-    /**
-     * Gets the current accelerometer pitch and roll angles.
-     *
-     * @param pitch The pitch angle returned (in degrees). If NULL then not returned.
-     * @param roll The roll angle returned (in degrees). If NULL then not returned.
-     */
-    static void getAccelerometerPitchAndRoll(float* pitch, float* roll);
-
 private:
 
     /**
      * Constructor. Private for static.
      */
-    Input();
+    Keyboard() { }
 };
 
 }

gameplay/src/Platform.h

@@ -73,22 +73,25 @@ public:
     static int getOrientationAngle();
 
     /**
-     * Indicates whether the platform supports an accelerometer.
-     * 
-     * @return true if the accelerometer is supported, false otherwise.
+     * Set if multi-touch is enabled on the platform
      */
-    static bool isAccelerometerSupported();
+    static void setMultiTouch(bool enabled);
+
+   /**
+    * Is multi-touch mode enabled.
+    */
+    static bool isMultiTouch();
 
     /**
-     * Gets the platform accelerometer pitch and roll.
+     * Gets the platform accelerometer values.
      * 
      * @param pitch The accelerometer pitch.
      * @param roll The accelerometer roll.
      */
-    static void getAccelerometerPitchAndRoll(float* pitch, float* roll);
+    static void getAccelerometerValues(float* pitch, float* roll);
 
     /**
-     * Swaps the 
+     * Swaps the frame buffer on the device.
      */
     static void swapBuffers();
 
@@ -104,8 +107,7 @@ private:
      */
     Platform(const Platform& copy);
 
-    Game* _game;
-
+    Game* _game;                // The game this platform is interfacing with.
 };
 
 }

gameplay/src/PlatformMacOS.mm

@@ -4,7 +4,6 @@
 #include "Platform.h"
 #include "FileSystem.h"
 #include "Game.h"
-#include "Input.h"
 
 #import <Cocoa/Cocoa.h>
 #import <QuartzCore/CVDisplayLink.h>
@@ -179,14 +178,14 @@ static CVReturn MyDisplayLinkCallback(CVDisplayLinkRef displayLink, const CVTime
 {
     NSPoint point = [event locationInWindow];
     __leftMouseDown = true;
-    _game->touch(point.x, WINDOW_HEIGHT - point.y, Input::TOUCHEVENT_PRESS);
+    _game->touchEvent(Touch::TOUCH_PRESS, point.x, WINDOW_HEIGHT - point.y, 0);
 }
 
 - (void) mouseUp: (NSEvent*) event
 {
     NSPoint point = [event locationInWindow];
     __leftMouseDown = false;
-    _game->touch(point.x, WINDOW_HEIGHT - point.y, Input::TOUCHEVENT_RELEASE);
+    _game->touchEvent(Touch::TOUCH_RELEASE, point.x, WINDOW_HEIGHT - point.y, 0);
 }
 
 - (void) mouseDragged: (NSEvent*) event
@@ -194,7 +193,7 @@ static CVReturn MyDisplayLinkCallback(CVDisplayLinkRef displayLink, const CVTime
     NSPoint point = [event locationInWindow];
     if (__leftMouseDown)
     {
-        _game->touch(point.x, WINDOW_HEIGHT - point.y, Input::TOUCHEVENT_MOVE);
+        _game->touchEvent(Touch::EVENT_MOVE, point.x, WINDOW_HEIGHT - point.y, 0);
     }
 }
 
@@ -253,194 +252,194 @@ int getKey(unsigned short keyCode, unsigned int modifierFlags)
     switch(keyCode)
     {
         case 0x69:
-            return Input::KEY_PRINT;
+            return Keyboard::KEY_PRINT;
         case 0x35:
-            return Input::KEY_ESCAPE;
+            return Keyboard::KEY_ESCAPE;
         case 0x33:
-            return Input::KEY_BACKSPACE;
+            return Keyboard::KEY_BACKSPACE;
         case 0x30:
-            return Input::KEY_TAB;
+            return Keyboard::KEY_TAB;
         case 0x24:
-            return Input::KEY_RETURN;
+            return Keyboard::KEY_RETURN;
         case 0x72:
-            return Input::KEY_INSERT;
+            return Keyboard::KEY_INSERT;
         case 0x73:
-            return Input::KEY_HOME;
+            return Keyboard::KEY_HOME;
         case 0x74:
-            return Input::KEY_PG_UP;
+            return Keyboard::KEY_PG_UP;
         case 0x79:
-            return Input::KEY_PG_DOWN;
+            return Keyboard::KEY_PG_DOWN;
         case 0x75:
-            return Input::KEY_DELETE;
+            return Keyboard::KEY_DELETE;
         case 0x77:
-            return Input::KEY_END;
+            return Keyboard::KEY_END;
         case 0x7B:
-            return Input::KEY_LEFT_ARROW;
+            return Keyboard::KEY_LEFT_ARROW;
         case 0x7C:
-            return Input::KEY_RIGHT_ARROW;
+            return Keyboard::KEY_RIGHT_ARROW;
         case 0x7E:
-            return Input::KEY_UP_ARROW;
+            return Keyboard::KEY_UP_ARROW;
         case 0x7D:
-            return Input::KEY_DOWN_ARROW;
+            return Keyboard::KEY_DOWN_ARROW;
         case 0x47:
-            return Input::KEY_NUM_LOCK;
+            return Keyboard::KEY_NUM_LOCK;
         case 0x45:
-            return Input::KEY_KP_PLUS;
+            return Keyboard::KEY_KP_PLUS;
         case 0x4E:
-            return Input::KEY_KP_MINUS;
+            return Keyboard::KEY_KP_MINUS;
         case 0x43:
-            return Input::KEY_KP_MULTIPLY;
+            return Keyboard::KEY_KP_MULTIPLY;
         case 0x4B:
-            return Input::KEY_KP_DIVIDE;
+            return Keyboard::KEY_KP_DIVIDE;
         case 0x59:
-            return Input::KEY_KP_HOME;
+            return Keyboard::KEY_KP_HOME;
         case 0x5B:
-            return Input::KEY_KP_UP;
+            return Keyboard::KEY_KP_UP;
         case 0x5C:
-            return Input::KEY_KP_PG_UP;
+            return Keyboard::KEY_KP_PG_UP;
         case 0x56:
-            return Input::KEY_KP_LEFT;
+            return Keyboard::KEY_KP_LEFT;
         case 0x57:
-            return Input::KEY_KP_FIVE;
+            return Keyboard::KEY_KP_FIVE;
         case 0x58:
-            return Input::KEY_KP_RIGHT;
+            return Keyboard::KEY_KP_RIGHT;
         case 0x53:
-            return Input::KEY_KP_END;
+            return Keyboard::KEY_KP_END;
         case 0x54:
-            return Input::KEY_KP_DOWN;
+            return Keyboard::KEY_KP_DOWN;
         case 0x55:
-            return Input::KEY_KP_PG_DOWN;
+            return Keyboard::KEY_KP_PG_DOWN;
         case 0x52:
-            return Input::KEY_KP_INSERT;
+            return Keyboard::KEY_KP_INSERT;
         case 0x41:
-            return Input::KEY_KP_DELETE;
+            return Keyboard::KEY_KP_DELETE;
         case 0x7A:
-            return Input::KEY_F1;
+            return Keyboard::KEY_F1;
         case 0x78:
-            return Input::KEY_F2;
+            return Keyboard::KEY_F2;
         case 0x63:
-            return Input::KEY_F3;
+            return Keyboard::KEY_F3;
         case 0x76:
-            return Input::KEY_F4;
+            return Keyboard::KEY_F4;
         case 0x60:
-            return Input::KEY_F5;
+            return Keyboard::KEY_F5;
         case 0x61:
-            return Input::KEY_F6;
+            return Keyboard::KEY_F6;
         case 0x62:
-            return Input::KEY_F7;
+            return Keyboard::KEY_F7;
         case 0x64:
-            return Input::KEY_F8;
+            return Keyboard::KEY_F8;
         case 0x65:
-            return Input::KEY_F9;
+            return Keyboard::KEY_F9;
         case 0x6D:
-            return Input::KEY_F10;
+            return Keyboard::KEY_F10;
         
         // MACOS reserved:
-        //return Input::KEY_F11;
-        //return Input::KEY_F12;
-        // return Input::KEY_PAUSE;
-        // return Input::KEY_SCROLL_LOCK;
+        //return Keyboard::KEY_F11;
+        //return Keyboard::KEY_F12;
+        // return Keyboard::KEY_PAUSE;
+        // return Keyboard::KEY_SCROLL_LOCK;
             
         case 0x31:
-            return Input::KEY_SPACE;
+            return Keyboard::KEY_SPACE;
         case 0x1D:
-            return __shiftDown ? Input::KEY_RIGHT_PARENTHESIS : Input::KEY_ZERO;
+            return __shiftDown ? Keyboard::KEY_RIGHT_PARENTHESIS : Keyboard::KEY_ZERO;
         case 0x12:
-            return __shiftDown ? Input::KEY_EXCLAM : Input::KEY_ONE;
+            return __shiftDown ? Keyboard::KEY_EXCLAM : Keyboard::KEY_ONE;
         case 0x13:
-            return __shiftDown ? Input::KEY_AT : Input::KEY_TWO;
+            return __shiftDown ? Keyboard::KEY_AT : Keyboard::KEY_TWO;
         case 0x14:
-            return __shiftDown ? Input::KEY_NUMBER : Input::KEY_THREE;
+            return __shiftDown ? Keyboard::KEY_NUMBER : Keyboard::KEY_THREE;
         case 0x15:
-            return __shiftDown ? Input::KEY_DOLLAR : Input::KEY_FOUR;
+            return __shiftDown ? Keyboard::KEY_DOLLAR : Keyboard::KEY_FOUR;
         case 0x17:
-            return __shiftDown ? Input::KEY_PERCENT : Input::KEY_FIVE;
+            return __shiftDown ? Keyboard::KEY_PERCENT : Keyboard::KEY_FIVE;
         case 0x16:
-            return __shiftDown ? Input::KEY_CIRCUMFLEX : Input::KEY_SIX;
+            return __shiftDown ? Keyboard::KEY_CIRCUMFLEX : Keyboard::KEY_SIX;
         case 0x1A:
-            return __shiftDown ? Input::KEY_AMPERSAND : Input::KEY_SEVEN;
+            return __shiftDown ? Keyboard::KEY_AMPERSAND : Keyboard::KEY_SEVEN;
         case 0x1C:
-            return __shiftDown ? Input::KEY_ASTERISK : Input::KEY_EIGHT;
+            return __shiftDown ? Keyboard::KEY_ASTERISK : Keyboard::KEY_EIGHT;
         case 0x19:
-            return __shiftDown ? Input::KEY_LEFT_PARENTHESIS : Input::KEY_NINE;
+            return __shiftDown ? Keyboard::KEY_LEFT_PARENTHESIS : Keyboard::KEY_NINE;
         case 0x18:
-            return __shiftDown ? Input::KEY_EQUAL : Input::KEY_PLUS;
+            return __shiftDown ? Keyboard::KEY_EQUAL : Keyboard::KEY_PLUS;
         case 0x2B:
-            return __shiftDown ? Input::KEY_LESS_THAN : Input::KEY_COMMA;
+            return __shiftDown ? Keyboard::KEY_LESS_THAN : Keyboard::KEY_COMMA;
         case 0x1B:
-            return __shiftDown ? Input::KEY_UNDERSCORE : Input::KEY_MINUS;
+            return __shiftDown ? Keyboard::KEY_UNDERSCORE : Keyboard::KEY_MINUS;
         case 0x2F:
-            return __shiftDown ? Input::KEY_GREATER_THAN : Input::KEY_PERIOD;
+            return __shiftDown ? Keyboard::KEY_GREATER_THAN : Keyboard::KEY_PERIOD;
         case 0x29:
-            return __shiftDown ? Input::KEY_COLON : Input::KEY_SEMICOLON;
+            return __shiftDown ? Keyboard::KEY_COLON : Keyboard::KEY_SEMICOLON;
         case 0x2C:
-            return __shiftDown ? Input::KEY_QUESTION : Input::KEY_SLASH;
+            return __shiftDown ? Keyboard::KEY_QUESTION : Keyboard::KEY_SLASH;
         case 0x32:
-            return __shiftDown ? Input::KEY_GRAVE : Input::KEY_TILDE;
+            return __shiftDown ? Keyboard::KEY_GRAVE : Keyboard::KEY_TILDE;
         case 0x21:
-            return __shiftDown ? Input::KEY_LEFT_BRACE : Input::KEY_LEFT_BRACKET;
+            return __shiftDown ? Keyboard::KEY_LEFT_BRACE : Keyboard::KEY_LEFT_BRACKET;
         case 0x2A:
-            return __shiftDown ? Input::KEY_BAR : Input::KEY_BACK_SLASH;
+            return __shiftDown ? Keyboard::KEY_BAR : Keyboard::KEY_BACK_SLASH;
         case 0x1E:
-            return __shiftDown ? Input::KEY_RIGHT_BRACE : Input::KEY_RIGHT_BRACKET;
+            return __shiftDown ? Keyboard::KEY_RIGHT_BRACE : Keyboard::KEY_RIGHT_BRACKET;
         case 0x27:
-            return __shiftDown ? Input::KEY_QUOTE : Input::KEY_APOSTROPHE;
+            return __shiftDown ? Keyboard::KEY_QUOTE : Keyboard::KEY_APOSTROPHE;
             
         case 0x00:
-             return __shiftDown ? Input::KEY_CAPITAL_A : Input::KEY_A;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_A : Keyboard::KEY_A;
         case 0x0B:
-             return __shiftDown ? Input::KEY_CAPITAL_B : Input::KEY_B;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_B : Keyboard::KEY_B;
         case 0x08:
-             return __shiftDown ? Input::KEY_CAPITAL_C : Input::KEY_C;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_C : Keyboard::KEY_C;
         case 0x02:
-             return __shiftDown ? Input::KEY_CAPITAL_D : Input::KEY_D;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_D : Keyboard::KEY_D;
         case 0x0E:
-             return __shiftDown ? Input::KEY_CAPITAL_E : Input::KEY_E;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_E : Keyboard::KEY_E;
         case 0x03:
-             return __shiftDown ? Input::KEY_CAPITAL_F : Input::KEY_F;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_F : Keyboard::KEY_F;
         case 0x05:
-             return __shiftDown ? Input::KEY_CAPITAL_G : Input::KEY_G;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_G : Keyboard::KEY_G;
         case 0x04:
-             return __shiftDown ? Input::KEY_CAPITAL_H : Input::KEY_H;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_H : Keyboard::KEY_H;
         case 0x22:
-             return __shiftDown ? Input::KEY_CAPITAL_I : Input::KEY_I;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_I : Keyboard::KEY_I;
         case 0x26:
-             return __shiftDown ? Input::KEY_CAPITAL_J : Input::KEY_J;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_J : Keyboard::KEY_J;
         case 0x28:
-             return __shiftDown ? Input::KEY_CAPITAL_K : Input::KEY_K;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_K : Keyboard::KEY_K;
         case 0x25:
-             return __shiftDown ? Input::KEY_CAPITAL_L : Input::KEY_L;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_L : Keyboard::KEY_L;
         case 0x2E:
-             return __shiftDown ? Input::KEY_CAPITAL_M : Input::KEY_M;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_M : Keyboard::KEY_M;
         case 0x2D:
-             return __shiftDown ? Input::KEY_CAPITAL_N : Input::KEY_N;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_N : Keyboard::KEY_N;
         case 0x1F:
-             return __shiftDown ? Input::KEY_CAPITAL_O : Input::KEY_O;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_O : Keyboard::KEY_O;
         case 0x23:
-             return __shiftDown ? Input::KEY_CAPITAL_P : Input::KEY_P;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_P : Keyboard::KEY_P;
         case 0x0C:
-             return __shiftDown ? Input::KEY_CAPITAL_Q : Input::KEY_Q;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_Q : Keyboard::KEY_Q;
         case 0x0F:
-             return __shiftDown ? Input::KEY_CAPITAL_R : Input::KEY_R;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_R : Keyboard::KEY_R;
         case 0x01:
-             return __shiftDown ? Input::KEY_CAPITAL_S : Input::KEY_S;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_S : Keyboard::KEY_S;
         case 0x11:
-             return __shiftDown ? Input::KEY_CAPITAL_T : Input::KEY_T;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_T : Keyboard::KEY_T;
         case 0x20:
-             return __shiftDown ? Input::KEY_CAPITAL_U : Input::KEY_U;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_U : Keyboard::KEY_U;
         case 0x09:
-             return __shiftDown ? Input::KEY_CAPITAL_V : Input::KEY_V;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_V : Keyboard::KEY_V;
         case 0x0D:
-             return __shiftDown ? Input::KEY_CAPITAL_W : Input::KEY_W;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_W : Keyboard::KEY_W;
         case 0x07:
-             return __shiftDown ? Input::KEY_CAPITAL_X : Input::KEY_X;
+             return __shiftDown ? Keyboard::KEY_CAPITAL_X : Keyboard::KEY_X;
         case 0x10:
-            return __shiftDown ? Input::KEY_CAPITAL_Y : Input::KEY_Y;
+            return __shiftDown ? Keyboard::KEY_CAPITAL_Y : Keyboard::KEY_Y;
         case 0x06:
-            return __shiftDown ? Input::KEY_CAPITAL_Z : Input::KEY_Z;
+            return __shiftDown ? Keyboard::KEY_CAPITAL_Z : Keyboard::KEY_Z;
 
         default:
-            return Input::KEY_NONE;
+            return Keyboard::KEY_NONE;
     }
 }
 
@@ -448,47 +447,46 @@ int getKey(unsigned short keyCode, unsigned int modifierFlags)
 {
     unsigned int keyCode = [event keyCode];
     unsigned int flags = [event modifierFlags];
-    
     switch (keyCode) 
     {
         case 0x39:
-            _game->keyPress(Input::KEY_CAPS_LOCK, (flags & NSAlphaShiftKeyMask) ? Input::KEYEVENT_DOWN : Input::KEYEVENT_UP);
+            _game->keyEvent((flags & NSAlphaShiftKeyMask) ? Keyboard::KEY_PRESS : Keyboard::KEY_RELEASE, Keyboard::KEY_CAPS_LOCK);
             break;
         case 0x38:
-            _game->keyPress(Input::KEY_LEFT_SHIFT, (flags & NSShiftKeyMask) ? Input::KEYEVENT_DOWN : Input::KEYEVENT_UP);
+            _game->keyEvent((flags & NSShiftKeyMask) ? Keyboard::KEY_PRESS : Keyboard::KEY_RELEASE, Keyboard::KEY_LEFT_SHIFT);
             break;
         case 0x3C:
-            _game->keyPress(Input::KEY_RIGHT_SHIFT, (flags & NSShiftKeyMask) ? Input::KEYEVENT_DOWN : Input::KEYEVENT_UP);
+            _game->keyEvent((flags & NSShiftKeyMask) ? Keyboard::KEYEVENT_DOWN : Keyboard::KEY_RELEASE, Keyboard::KEY_RIGHT_SHIFT);
             break;
         case 0x3A:
-            _game->keyPress(Input::KEY_LEFT_ALT, (flags & NSAlternateKeyMask) ? Input::KEYEVENT_DOWN : Input::KEYEVENT_UP);
+            _game->keyEvent((flags & NSAlternateKeyMask) ? Keyboard::KEYEVENT_DOWN : Keyboard::KEY_RELEASE, Keyboard::KEY_LEFT_ALT);
             break;
         case 0x3D:
-            _game->keyPress(Input::KEY_RIGHT_ALT, (flags & NSAlternateKeyMask) ? Input::KEYEVENT_DOWN : Input::KEYEVENT_UP);
+            _game->keyEvent((flags & NSAlternateKeyMask) ? Keyboard::KEYEVENT_DOWN : Keyboard::KEY_RELEASE, Keyboard::KEY_RIGHT_ALT);
             break;
         case 0x3B:
-            _game->keyPress(Input::KEY_LEFT_CTRL, (flags & NSControlKeyMask) ? Input::KEYEVENT_DOWN : Input::KEYEVENT_UP);
+            _game->keyEvent((flags & NSControlKeyMask) ? Keyboard::KEYEVENT_DOWN : Keyboard::KEY_RELEASE, Keyboard::KEY_LEFT_CTRL);
             break;
         case 0x3E:
-            _game->keyPress(Input::KEY_RIGHT_CTRL, (flags & NSControlKeyMask) ? Input::KEYEVENT_DOWN : Input::KEYEVENT_UP);
+            _game->keyEvent((flags & NSControlKeyMask) ? Keyboard::KEYEVENT_DOWN : Keyboard::KEY_RELEASE, Keyboard::KEY_RIGHT_CTRL);
             break;
         case 0x37:
-            _game->keyPress(Input::KEY_LEFT_HYPER, (flags & NSCommandKeyMask) ? Input::KEYEVENT_DOWN : Input::KEYEVENT_UP);
+            _game->keyEvent((flags & NSCommandKeyMask) ? Keyboard::KEYEVENT_DOWN : Keyboard::KEY_RELEASE, Keyboard::KEY_LEFT_HYPER);
             break;
         case 0x36:
-            _game->keyPress(Input::KEY_RIGHT_HYPER, (flags & NSCommandKeyMask) ? Input::KEYEVENT_DOWN : Input::KEYEVENT_UP);
+            _game->keyEvent((flags & NSCommandKeyMask) ? Keyboard::KEYEVENT_DOWN : Keyboard::KEY_RELEASE, Keyboard::KEY_RIGHT_HYPER);
             break;
     }
 }
 
 - (void) keyDown: (NSEvent*) event
 {    
-    _game->keyPress(getKey([event keyCode], [event modifierFlags]), Input::KEYEVENT_DOWN);
+    _game->keyEvent(getKey([event keyCode], [event modifierFlags]), Keyboard::KEYEVENT_PRESS);
 }
 
 - (void) keyUp: (NSEvent*) event
 {    
-    _game->keyPress(getKey([event keyCode], [event modifierFlags]), Input::KEYEVENT_UP);
+    _game->keyEvent(getKey([event keyCode], [event modifierFlags]), Keyboard::KEY_RELEASE);
 }
 
 @end
@@ -584,12 +582,7 @@ int Platform::getOrientationAngle()
     return 0;
 }
 
-bool Platform::isAccelerometerSupported()
-{
-    return true;
-}
-
-void Platform::getAccelerometerPitchAndRoll(float* pitch, float* roll)
+void Platform::getAccelerometerValues(float* pitch, float* roll)
 {
     *pitch = __pitch;
     *roll = __roll;
@@ -600,7 +593,7 @@ void Platform::swapBuffers()
     if (__view)
         CGLFlushDrawable((CGLContextObj)[[__view openGLContext] CGLContextObj]);
 }
-    
+
 }
 
 #endif

gameplay/src/PlatformQNX.cpp

@@ -4,9 +4,9 @@
 #include "Platform.h"
 #include "FileSystem.h"
 #include "Game.h"
-#include "Input.h"
 #include <sys/keycodes.h>
 #include <screen/screen.h>
+#include <input/screen_helpers.h>
 #include <bps/bps.h>
 #include <bps/event.h>
 #include <bps/screen.h>
@@ -14,6 +14,8 @@
 #include <bps/accelerometer.h>
 #include <bps/orientation.h>
 
+#define TOUCH_COUNT_MAX     4
+
 using namespace std;
 
 struct timespec __timespec;
@@ -29,6 +31,7 @@ static EGLContext __eglContext = EGL_NO_CONTEXT;
 static EGLSurface __eglSurface = EGL_NO_SURFACE;
 static EGLConfig __eglConfig = 0;
 static int __orientationAngle;
+static bool __multiTouch = false;
 
 static const char* __glExtensions;
 PFNGLBINDVERTEXARRAYOESPROC glBindVertexArray = NULL;
@@ -39,321 +42,321 @@ PFNGLISVERTEXARRAYOESPROC glIsVertexArray = NULL;
 namespace gameplay
 {
 
-// Gets the Input::Key enumeration constant that corresponds to the given QNX key code.
-static Input::Key getGameplayInputKey(int qnxKeycode)
+// Gets the Keyboard::Key enumeration constant that corresponds to the given QNX key code.
+static Keyboard::Key getKey(int qnxKeycode)
 {
     switch (qnxKeycode)
     {
     case KEYCODE_SYSREQ:
-        return Input::KEY_SYSREQ;
+        return Keyboard::KEY_SYSREQ;
     case KEYCODE_BREAK:
-        return Input::KEY_BREAK;
+        return Keyboard::KEY_BREAK;
     case KEYCODE_MENU:
-        return Input::KEY_MENU;
+        return Keyboard::KEY_MENU;
     case KEYCODE_KP_ENTER:
-        return Input::KEY_KP_ENTER;
+        return Keyboard::KEY_KP_ENTER;
     case KEYCODE_PAUSE:
-        return Input::KEY_PAUSE;
+        return Keyboard::KEY_PAUSE;
     case KEYCODE_SCROLL_LOCK:
-        return Input::KEY_SCROLL_LOCK;
+        return Keyboard::KEY_SCROLL_LOCK;
     case KEYCODE_PRINT:
-        return Input::KEY_PRINT;
+        return Keyboard::KEY_PRINT;
     case KEYCODE_ESCAPE:
-        return Input::KEY_ESCAPE;
+        return Keyboard::KEY_ESCAPE;
     case KEYCODE_BACKSPACE:
-        return Input::KEY_BACKSPACE;
+        return Keyboard::KEY_BACKSPACE;
     case KEYCODE_BACK_TAB:
-        return Input::KEY_BACK_TAB;
+        return Keyboard::KEY_BACK_TAB;
     case KEYCODE_TAB:
-        return Input::KEY_TAB;
+        return Keyboard::KEY_TAB;
     case KEYCODE_RETURN:
-        return Input::KEY_RETURN;
+        return Keyboard::KEY_RETURN;
     case KEYCODE_CAPS_LOCK:
-        return Input::KEY_CAPS_LOCK;
+        return Keyboard::KEY_CAPS_LOCK;
     case KEYCODE_LEFT_SHIFT:
-        return Input::KEY_LEFT_SHIFT;
+        return Keyboard::KEY_LEFT_SHIFT;
     case KEYCODE_RIGHT_SHIFT:
-        return Input::KEY_RIGHT_SHIFT;
+        return Keyboard::KEY_RIGHT_SHIFT;
     case KEYCODE_LEFT_CTRL:
-        return Input::KEY_LEFT_CTRL;
+        return Keyboard::KEY_LEFT_CTRL;
     case KEYCODE_RIGHT_CTRL:
-        return Input::KEY_RIGHT_CTRL;
+        return Keyboard::KEY_RIGHT_CTRL;
     case KEYCODE_LEFT_ALT:
-        return Input::KEY_LEFT_ALT;
+        return Keyboard::KEY_LEFT_ALT;
     case KEYCODE_RIGHT_ALT:
-        return Input::KEY_RIGHT_ALT;
+        return Keyboard::KEY_RIGHT_ALT;
     case KEYCODE_LEFT_HYPER:
-        return Input::KEY_LEFT_HYPER;
+        return Keyboard::KEY_LEFT_HYPER;
     case KEYCODE_RIGHT_HYPER:
-        return Input::KEY_RIGHT_HYPER;
+        return Keyboard::KEY_RIGHT_HYPER;
     case KEYCODE_INSERT:
-        return Input::KEY_INSERT;
+        return Keyboard::KEY_INSERT;
     case KEYCODE_HOME:
-        return Input::KEY_HOME;
+        return Keyboard::KEY_HOME;
     case KEYCODE_PG_UP:
-        return Input::KEY_PG_UP;
+        return Keyboard::KEY_PG_UP;
     case KEYCODE_DELETE:
-        return Input::KEY_DELETE;
+        return Keyboard::KEY_DELETE;
     case KEYCODE_END:
-        return Input::KEY_END;
+        return Keyboard::KEY_END;
     case KEYCODE_PG_DOWN:
-        return Input::KEY_PG_DOWN;
+        return Keyboard::KEY_PG_DOWN;
     case KEYCODE_LEFT:
-        return Input::KEY_LEFT_ARROW;
+        return Keyboard::KEY_LEFT_ARROW;
     case KEYCODE_RIGHT:
-        return Input::KEY_RIGHT_ARROW;
+        return Keyboard::KEY_RIGHT_ARROW;
     case KEYCODE_UP:
-        return Input::KEY_UP_ARROW;
+        return Keyboard::KEY_UP_ARROW;
     case KEYCODE_DOWN:
-        return Input::KEY_DOWN_ARROW;
+        return Keyboard::KEY_DOWN_ARROW;
     case KEYCODE_NUM_LOCK:
-        return Input::KEY_NUM_LOCK;
+        return Keyboard::KEY_NUM_LOCK;
     case KEYCODE_KP_PLUS:
-        return Input::KEY_KP_PLUS;
+        return Keyboard::KEY_KP_PLUS;
     case KEYCODE_KP_MINUS:
-        return Input::KEY_KP_MINUS;
+        return Keyboard::KEY_KP_MINUS;
     case KEYCODE_KP_MULTIPLY:
-        return Input::KEY_KP_MULTIPLY;
+        return Keyboard::KEY_KP_MULTIPLY;
     case KEYCODE_KP_DIVIDE:
-        return Input::KEY_KP_DIVIDE;
+        return Keyboard::KEY_KP_DIVIDE;
     case KEYCODE_KP_HOME:
-        return Input::KEY_KP_HOME;
+        return Keyboard::KEY_KP_HOME;
     case KEYCODE_KP_UP:
-        return Input::KEY_KP_UP;
+        return Keyboard::KEY_KP_UP;
     case KEYCODE_KP_PG_UP:
-        return Input::KEY_KP_PG_UP;
+        return Keyboard::KEY_KP_PG_UP;
     case KEYCODE_KP_LEFT:
-        return Input::KEY_KP_LEFT;
+        return Keyboard::KEY_KP_LEFT;
     case KEYCODE_KP_FIVE:
-        return Input::KEY_KP_FIVE;
+        return Keyboard::KEY_KP_FIVE;
     case KEYCODE_KP_RIGHT:
-        return Input::KEY_KP_RIGHT;
+        return Keyboard::KEY_KP_RIGHT;
     case KEYCODE_KP_END:
-        return Input::KEY_KP_END;
+        return Keyboard::KEY_KP_END;
     case KEYCODE_KP_DOWN:
-        return Input::KEY_KP_DOWN;
+        return Keyboard::KEY_KP_DOWN;
     case KEYCODE_KP_PG_DOWN:
-        return Input::KEY_KP_PG_DOWN;
+        return Keyboard::KEY_KP_PG_DOWN;
     case KEYCODE_KP_INSERT:
-        return Input::KEY_KP_INSERT;
+        return Keyboard::KEY_KP_INSERT;
     case KEYCODE_KP_DELETE:
-        return Input::KEY_KP_DELETE;
+        return Keyboard::KEY_KP_DELETE;
     case KEYCODE_F1:
-        return Input::KEY_F1;
+        return Keyboard::KEY_F1;
     case KEYCODE_F2:
-        return Input::KEY_F2;
+        return Keyboard::KEY_F2;
     case KEYCODE_F3:
-        return Input::KEY_F3;
+        return Keyboard::KEY_F3;
     case KEYCODE_F4:
-        return Input::KEY_F4;
+        return Keyboard::KEY_F4;
     case KEYCODE_F5:
-        return Input::KEY_F5;
+        return Keyboard::KEY_F5;
     case KEYCODE_F6:
-        return Input::KEY_F6;
+        return Keyboard::KEY_F6;
     case KEYCODE_F7:
-        return Input::KEY_F7;
+        return Keyboard::KEY_F7;
     case KEYCODE_F8:
-        return Input::KEY_F8;
+        return Keyboard::KEY_F8;
     case KEYCODE_F9:
-        return Input::KEY_F9;
+        return Keyboard::KEY_F9;
     case KEYCODE_F10:
-        return Input::KEY_F10;
+        return Keyboard::KEY_F10;
     case KEYCODE_F11:
-        return Input::KEY_F11;
+        return Keyboard::KEY_F11;
     case KEYCODE_F12:
-        return Input::KEY_F12;
+        return Keyboard::KEY_F12;
     case KEYCODE_SPACE:
-        return Input::KEY_SPACE;
+        return Keyboard::KEY_SPACE;
     case KEYCODE_RIGHT_PAREN:
-        return Input::KEY_RIGHT_PARENTHESIS;
+        return Keyboard::KEY_RIGHT_PARENTHESIS;
     case KEYCODE_ZERO:
-        return Input::KEY_ZERO;
+        return Keyboard::KEY_ZERO;
     case KEYCODE_EXCLAM:
-        return Input::KEY_EXCLAM;
+        return Keyboard::KEY_EXCLAM;
     case KEYCODE_ONE:
-        return Input::KEY_ONE;
+        return Keyboard::KEY_ONE;
     case KEYCODE_AT:
-        return Input::KEY_AT;
+        return Keyboard::KEY_AT;
     case KEYCODE_TWO:
-        return Input::KEY_TWO;
+        return Keyboard::KEY_TWO;
     case KEYCODE_NUMBER:
-        return Input::KEY_NUMBER;
+        return Keyboard::KEY_NUMBER;
     case KEYCODE_THREE:
-        return Input::KEY_THREE;
+        return Keyboard::KEY_THREE;
     case KEYCODE_DOLLAR:
-        return Input::KEY_DOLLAR;
+        return Keyboard::KEY_DOLLAR;
     case KEYCODE_FOUR:
-        return Input::KEY_FOUR;
+        return Keyboard::KEY_FOUR;
     case KEYCODE_PERCENT:
-        return Input::KEY_PERCENT;
+        return Keyboard::KEY_PERCENT;
     case KEYCODE_FIVE:
-        return Input::KEY_FIVE;
+        return Keyboard::KEY_FIVE;
     case KEYCODE_CIRCUMFLEX:
-        return Input::KEY_CIRCUMFLEX;
+        return Keyboard::KEY_CIRCUMFLEX;
     case KEYCODE_SIX:
-        return Input::KEY_SIX;
+        return Keyboard::KEY_SIX;
     case KEYCODE_AMPERSAND:
-        return Input::KEY_AMPERSAND;
+        return Keyboard::KEY_AMPERSAND;
     case KEYCODE_SEVEN:
-        return Input::KEY_SEVEN;
+        return Keyboard::KEY_SEVEN;
     case KEYCODE_ASTERISK:
-        return Input::KEY_ASTERISK;
+        return Keyboard::KEY_ASTERISK;
     case KEYCODE_EIGHT:
-        return Input::KEY_EIGHT;
+        return Keyboard::KEY_EIGHT;
     case KEYCODE_LEFT_PAREN:
-        return Input::KEY_LEFT_PARENTHESIS;
+        return Keyboard::KEY_LEFT_PARENTHESIS;
     case KEYCODE_NINE:
-        return Input::KEY_NINE;
+        return Keyboard::KEY_NINE;
     case KEYCODE_EQUAL:
-        return Input::KEY_EQUAL;
+        return Keyboard::KEY_EQUAL;
     case KEYCODE_PLUS:
-        return Input::KEY_PLUS;
+        return Keyboard::KEY_PLUS;
     case KEYCODE_LESS_THAN:
-        return Input::KEY_LESS_THAN;
+        return Keyboard::KEY_LESS_THAN;
     case KEYCODE_COMMA:
-        return Input::KEY_COMMA;
+        return Keyboard::KEY_COMMA;
     case KEYCODE_UNDERSCORE:
-        return Input::KEY_UNDERSCORE;
+        return Keyboard::KEY_UNDERSCORE;
     case KEYCODE_MINUS:
-        return Input::KEY_MINUS;
+        return Keyboard::KEY_MINUS;
     case KEYCODE_GREATER_THAN:
-        return Input::KEY_GREATER_THAN;
+        return Keyboard::KEY_GREATER_THAN;
     case KEYCODE_PERIOD:
-        return Input::KEY_PERIOD;
+        return Keyboard::KEY_PERIOD;
     case KEYCODE_COLON:
-        return Input::KEY_COLON;
+        return Keyboard::KEY_COLON;
     case KEYCODE_SEMICOLON:
-        return Input::KEY_SEMICOLON;
+        return Keyboard::KEY_SEMICOLON;
     case KEYCODE_QUESTION:
-        return Input::KEY_QUESTION;
+        return Keyboard::KEY_QUESTION;
     case KEYCODE_SLASH:
-        return Input::KEY_SLASH;
+        return Keyboard::KEY_SLASH;
     case KEYCODE_GRAVE:
-        return Input::KEY_GRAVE;
+        return Keyboard::KEY_GRAVE;
     case KEYCODE_TILDE:
-        return Input::KEY_TILDE;
+        return Keyboard::KEY_TILDE;
     case KEYCODE_LEFT_BRACE:
-        return Input::KEY_LEFT_BRACE;
+        return Keyboard::KEY_LEFT_BRACE;
     case KEYCODE_LEFT_BRACKET:
-        return Input::KEY_LEFT_BRACKET;
+        return Keyboard::KEY_LEFT_BRACKET;
     case KEYCODE_BAR:
-        return Input::KEY_BAR;
+        return Keyboard::KEY_BAR;
     case KEYCODE_BACK_SLASH:
-        return Input::KEY_BACK_SLASH;
+        return Keyboard::KEY_BACK_SLASH;
     case KEYCODE_RIGHT_BRACE:
-        return Input::KEY_RIGHT_BRACE;
+        return Keyboard::KEY_RIGHT_BRACE;
     case KEYCODE_RIGHT_BRACKET:
-        return Input::KEY_RIGHT_BRACKET;
+        return Keyboard::KEY_RIGHT_BRACKET;
     case KEYCODE_QUOTE:
-        return Input::KEY_QUOTE;
+        return Keyboard::KEY_QUOTE;
     case KEYCODE_APOSTROPHE:
-        return Input::KEY_APOSTROPHE;
+        return Keyboard::KEY_APOSTROPHE;
     case KEYCODE_CAPITAL_A:
-        return Input::KEY_CAPITAL_A;
+        return Keyboard::KEY_CAPITAL_A;
     case KEYCODE_A:
-        return Input::KEY_A;
+        return Keyboard::KEY_A;
     case KEYCODE_CAPITAL_B:
-        return Input::KEY_CAPITAL_B;
+        return Keyboard::KEY_CAPITAL_B;
     case KEYCODE_B:
-        return Input::KEY_B;
+        return Keyboard::KEY_B;
     case KEYCODE_CAPITAL_C:
-        return Input::KEY_CAPITAL_C;
+        return Keyboard::KEY_CAPITAL_C;
     case KEYCODE_C:
-        return Input::KEY_C;
+        return Keyboard::KEY_C;
     case KEYCODE_CAPITAL_D:
-        return Input::KEY_CAPITAL_D;
+        return Keyboard::KEY_CAPITAL_D;
     case KEYCODE_D:
-        return Input::KEY_D;
+        return Keyboard::KEY_D;
     case KEYCODE_CAPITAL_E:
-        return Input::KEY_CAPITAL_E;
+        return Keyboard::KEY_CAPITAL_E;
     case KEYCODE_E:
-        return Input::KEY_E;
+        return Keyboard::KEY_E;
     case KEYCODE_CAPITAL_F:
-        return Input::KEY_CAPITAL_F;
+        return Keyboard::KEY_CAPITAL_F;
     case KEYCODE_F:
-        return Input::KEY_F;
+        return Keyboard::KEY_F;
     case KEYCODE_CAPITAL_G:
-        return Input::KEY_CAPITAL_G;
+        return Keyboard::KEY_CAPITAL_G;
     case KEYCODE_G:
-        return Input::KEY_G;
+        return Keyboard::KEY_G;
     case KEYCODE_CAPITAL_H:
-        return Input::KEY_CAPITAL_H;
+        return Keyboard::KEY_CAPITAL_H;
     case KEYCODE_H:
-        return Input::KEY_H;
+        return Keyboard::KEY_H;
     case KEYCODE_CAPITAL_I:
-        return Input::KEY_CAPITAL_I;
+        return Keyboard::KEY_CAPITAL_I;
     case KEYCODE_I:
-        return Input::KEY_I;
+        return Keyboard::KEY_I;
     case KEYCODE_CAPITAL_J:
-        return Input::KEY_CAPITAL_J;
+        return Keyboard::KEY_CAPITAL_J;
     case KEYCODE_J:
-        return Input::KEY_J;
+        return Keyboard::KEY_J;
     case KEYCODE_CAPITAL_K:
-        return Input::KEY_CAPITAL_K;
+        return Keyboard::KEY_CAPITAL_K;
     case KEYCODE_K:
-        return Input::KEY_K;
+        return Keyboard::KEY_K;
     case KEYCODE_CAPITAL_L:
-        return Input::KEY_CAPITAL_L;
+        return Keyboard::KEY_CAPITAL_L;
     case KEYCODE_L:
-        return Input::KEY_L;
+        return Keyboard::KEY_L;
     case KEYCODE_CAPITAL_M:
-        return Input::KEY_CAPITAL_M;
+        return Keyboard::KEY_CAPITAL_M;
     case KEYCODE_M:
-        return Input::KEY_M;
+        return Keyboard::KEY_M;
     case KEYCODE_CAPITAL_N:
-        return Input::KEY_CAPITAL_N;
+        return Keyboard::KEY_CAPITAL_N;
     case KEYCODE_N:
-        return Input::KEY_N;
+        return Keyboard::KEY_N;
     case KEYCODE_CAPITAL_O:
-        return Input::KEY_CAPITAL_O;
+        return Keyboard::KEY_CAPITAL_O;
     case KEYCODE_O:
-        return Input::KEY_O;
+        return Keyboard::KEY_O;
     case KEYCODE_CAPITAL_P:
-        return Input::KEY_CAPITAL_P;
+        return Keyboard::KEY_CAPITAL_P;
     case KEYCODE_P:
-        return Input::KEY_P;
+        return Keyboard::KEY_P;
     case KEYCODE_CAPITAL_Q:
-        return Input::KEY_CAPITAL_Q;
+        return Keyboard::KEY_CAPITAL_Q;
     case KEYCODE_Q:
-        return Input::KEY_Q;
+        return Keyboard::KEY_Q;
     case KEYCODE_CAPITAL_R:
-        return Input::KEY_CAPITAL_R;
+        return Keyboard::KEY_CAPITAL_R;
     case KEYCODE_R:
-        return Input::KEY_R;
+        return Keyboard::KEY_R;
     case KEYCODE_CAPITAL_S:
-        return Input::KEY_CAPITAL_S;
+        return Keyboard::KEY_CAPITAL_S;
     case KEYCODE_S:
-        return Input::KEY_S;
+        return Keyboard::KEY_S;
     case KEYCODE_CAPITAL_T:
-        return Input::KEY_CAPITAL_T;
+        return Keyboard::KEY_CAPITAL_T;
     case KEYCODE_T:
-        return Input::KEY_T;
+        return Keyboard::KEY_T;
     case KEYCODE_CAPITAL_U:
-        return Input::KEY_CAPITAL_U;
+        return Keyboard::KEY_CAPITAL_U;
     case KEYCODE_U:
-        return Input::KEY_U;
+        return Keyboard::KEY_U;
     case KEYCODE_CAPITAL_V:
-        return Input::KEY_CAPITAL_V;
+        return Keyboard::KEY_CAPITAL_V;
     case KEYCODE_V:
-        return Input::KEY_V;
+        return Keyboard::KEY_V;
     case KEYCODE_CAPITAL_W:
-        return Input::KEY_CAPITAL_W;
+        return Keyboard::KEY_CAPITAL_W;
     case KEYCODE_W:
-        return Input::KEY_W;
+        return Keyboard::KEY_W;
     case KEYCODE_CAPITAL_X:
-        return Input::KEY_CAPITAL_X;
+        return Keyboard::KEY_CAPITAL_X;
     case KEYCODE_X:
-        return Input::KEY_X;
+        return Keyboard::KEY_X;
     case KEYCODE_CAPITAL_Y:
-        return Input::KEY_CAPITAL_Y;
+        return Keyboard::KEY_CAPITAL_Y;
     case KEYCODE_Y:
-        return Input::KEY_Y;
+        return Keyboard::KEY_Y;
     case KEYCODE_CAPITAL_Z:
-        return Input::KEY_CAPITAL_Z;
+        return Keyboard::KEY_CAPITAL_Z;
     case KEYCODE_Z:
-        return Input::KEY_Z;
+        return Keyboard::KEY_Z;
     default:
-        return Input::KEY_NONE;
+        return Keyboard::KEY_NONE;
     }
 }
 
@@ -671,6 +674,8 @@ int Platform::enterMessagePump()
     int visible = 1;
     int position[2];
     int domain;
+    mtouch_event_t touchEvent;
+    int touchId = 0;
 
     // Get the initial time.
     clock_gettime(CLOCK_REALTIME, &__timespec);
@@ -686,7 +691,7 @@ int Platform::enterMessagePump()
         
         while (true)
         {
-            rc = bps_get_event(&event, 1);  // 1 = Hack for now until bps is fixed. Soon.
+            rc = bps_get_event(&event, 1);
             assert(rc == BPS_SUCCESS);
 
             if (event == NULL)
@@ -701,25 +706,57 @@ int Platform::enterMessagePump()
                 switch (eventType)
                 {
                     case SCREEN_EVENT_MTOUCH_TOUCH:
-                        screen_get_event_property_iv(__screenEvent, SCREEN_PROPERTY_POSITION, position);
-                        Game::getInstance()->touch(position[0], position[1], Input::TOUCHEVENT_PRESS);
+                    {
+                        if (!__multiTouch)
+                        {
+                            screen_get_event_property_iv(__screenEvent, SCREEN_PROPERTY_POSITION, position);
+                           Game::getInstance()->touchEvent(Touch::TOUCH_PRESS, position[0], position[1], 0);
+                        }
+                        else
+                        {
+                            screen_get_mtouch_event(__screenEvent, &touchEvent, 0);
+                            Game::getInstance()->touchEvent(Touch::TOUCH_PRESS, touchEvent.x, touchEvent.y, touchEvent.contact_id);
+                        }
+                        break;
+                    }
+
+                    case SCREEN_EVENT_MTOUCH_RELEASE:
+                    {
+                        if (!__multiTouch)
+                        {
+                            screen_get_event_property_iv(__screenEvent, SCREEN_PROPERTY_POSITION, position);
+                           Game::getInstance()->touchEvent(Touch::TOUCH_RELEASE, position[0], position[1], 0);
+                        }
+                        else
+                        {
+                            screen_get_mtouch_event(__screenEvent, &touchEvent, 0);
+                            Game::getInstance()->touchEvent(Touch::TOUCH_RELEASE, touchEvent.x, touchEvent.y, touchEvent.contact_id);
+                        }
                         break;
+                    }
+
                     case SCREEN_EVENT_MTOUCH_MOVE:
-                        screen_get_event_property_iv(__screenEvent, SCREEN_PROPERTY_POSITION, position);
-                        Game::getInstance()->touch(position[0], position[1], Input::TOUCHEVENT_MOVE);
+                    {
+                        if (!__multiTouch)
+                        {
+                            screen_get_event_property_iv(__screenEvent, SCREEN_PROPERTY_POSITION, position);
+                           Game::getInstance()->touchEvent(Touch::TOUCH_MOVE, position[0], position[1], 0);
+                        }
+                        else
+                        {
+                            screen_get_mtouch_event(__screenEvent, &touchEvent, 0);
+                            Game::getInstance()->touchEvent(Touch::TOUCH_MOVE, touchEvent.x, touchEvent.y, touchEvent.contact_id);
+                        }
                         break;
-                    case SCREEN_EVENT_MTOUCH_RELEASE:
-                        screen_get_event_property_iv(__screenEvent, SCREEN_PROPERTY_POSITION, position);
-                        Game::getInstance()->touch(position[0], position[1], Input::TOUCHEVENT_RELEASE);
                         break;
+                    }
 
                     case SCREEN_EVENT_KEYBOARD:
                     {
-                        // Keyboard event.
                         screen_get_event_property_iv(__screenEvent, SCREEN_PROPERTY_KEY_FLAGS, &flags);
                         screen_get_event_property_iv(__screenEvent, SCREEN_PROPERTY_KEY_SYM, &value);
-                        int keyEvent = flags & KEY_DOWN ? Input::KEYEVENT_DOWN : Input::KEYEVENT_UP;
-                        Game::getInstance()->keyPress(getGameplayInputKey(value), keyEvent);
+                        gameplay::Keyboard::KeyEvent evt = (flags & KEY_DOWN) ? gameplay::Keyboard::KEY_PRESS :  gameplay::Keyboard::KEY_RELEASE;
+                        Game::getInstance()->keyEvent(evt, getKey(value));
                         break;
                     }
                 }
@@ -808,12 +845,17 @@ int Platform::getOrientationAngle()
     return __orientationAngle;
 }
 
-bool Platform::isAccelerometerSupported()
+void Platform::setMultiTouch(bool enabled)
+{
+    __multiTouch = enabled;
+}
+
+bool Platform::isMultiTouch()
 {
-    return accelerometer_is_supported();
+    return __multiTouch;
 }
 
-void Platform::getAccelerometerPitchAndRoll(float* pitch, float* roll)
+void Platform::getAccelerometerValues(float* pitch, float* roll)
 {
     double tx, ty, tz;
     accelerometer_read_forces(&tx, &ty, &tz);

gameplay/src/PlatformWin32.cpp

@@ -17,224 +17,224 @@ static HWND __hwnd = 0;
 static HDC __hdc = 0;
 static HGLRC __hrc = 0;
 
-// Gets the gameplay::Input::Key enumeration constant that corresponds
+// Gets the gameplay::Keyboard::Key enumeration constant that corresponds
 // to the given key and shift modifier combination.
-static gameplay::Input::Key getGameplayInputKey(WPARAM win32KeyCode, bool shiftDown)
+static gameplay::Keyboard::Key getKey(WPARAM win32KeyCode, bool shiftDown)
 {
     // TODO: Handle the following keys
-    //gameplay::Input::KEY_SYSREQ
-    //gameplay::Input::KEY_BREAK
-    //gameplay::Input::KEY_MENU
-    //gameplay::Input::KEY_KP_ENTER
+    //gameplay::Keyboard::KEY_SYSREQ
+    //gameplay::Keyboard::KEY_BREAK
+    //gameplay::Keyboard::KEY_MENU
+    //gameplay::Keyboard::KEY_KP_ENTER
 
     switch (win32KeyCode)
     {
     case VK_PAUSE:
-        return gameplay::Input::KEY_PAUSE;
+        return gameplay::Keyboard::KEY_PAUSE;
     case VK_SCROLL:
-        return gameplay::Input::KEY_SCROLL_LOCK;
+        return gameplay::Keyboard::KEY_SCROLL_LOCK;
     case VK_PRINT:
-        return gameplay::Input::KEY_PRINT;
+        return gameplay::Keyboard::KEY_PRINT;
     case VK_ESCAPE:
-        return gameplay::Input::KEY_ESCAPE;
+        return gameplay::Keyboard::KEY_ESCAPE;
     case VK_BACK:
-        return gameplay::Input::KEY_BACKSPACE;
+        return gameplay::Keyboard::KEY_BACKSPACE;
     case VK_TAB:
-        return shiftDown ? gameplay::Input::KEY_BACK_TAB : gameplay::Input::KEY_TAB;
+        return shiftDown ? gameplay::Keyboard::KEY_BACK_TAB : gameplay::Keyboard::KEY_TAB;
     case VK_RETURN:
-        return gameplay::Input::KEY_RETURN;
+        return gameplay::Keyboard::KEY_RETURN;
     case VK_CAPITAL:
-        return gameplay::Input::KEY_CAPS_LOCK;
+        return gameplay::Keyboard::KEY_CAPS_LOCK;
     case VK_LSHIFT:
-        return gameplay::Input::KEY_LEFT_SHIFT;
+        return gameplay::Keyboard::KEY_LEFT_SHIFT;
     case VK_RSHIFT:
-        return gameplay::Input::KEY_RIGHT_SHIFT;
+        return gameplay::Keyboard::KEY_RIGHT_SHIFT;
     case VK_LCONTROL:
-        return gameplay::Input::KEY_LEFT_CTRL;
+        return gameplay::Keyboard::KEY_LEFT_CTRL;
     case VK_RCONTROL:
-        return gameplay::Input::KEY_RIGHT_CTRL;
+        return gameplay::Keyboard::KEY_RIGHT_CTRL;
     case VK_LMENU:
-        return gameplay::Input::KEY_LEFT_ALT;
+        return gameplay::Keyboard::KEY_LEFT_ALT;
     case VK_RMENU:
-        return gameplay::Input::KEY_RIGHT_ALT;
+        return gameplay::Keyboard::KEY_RIGHT_ALT;
     case VK_LWIN:
-        return gameplay::Input::KEY_LEFT_HYPER;
+        return gameplay::Keyboard::KEY_LEFT_HYPER;
     case VK_RWIN:
-        return gameplay::Input::KEY_RIGHT_HYPER;
+        return gameplay::Keyboard::KEY_RIGHT_HYPER;
     case VK_INSERT:
-        return gameplay::Input::KEY_INSERT;
+        return gameplay::Keyboard::KEY_INSERT;
     case VK_HOME:
-        return gameplay::Input::KEY_HOME;
+        return gameplay::Keyboard::KEY_HOME;
     case VK_PRIOR:
-        return gameplay::Input::KEY_PG_UP;
+        return gameplay::Keyboard::KEY_PG_UP;
     case VK_DELETE:
-        return gameplay::Input::KEY_DELETE;
+        return gameplay::Keyboard::KEY_DELETE;
     case VK_END:
-        return gameplay::Input::KEY_END;
+        return gameplay::Keyboard::KEY_END;
     case VK_NEXT:
-        return gameplay::Input::KEY_PG_DOWN;
+        return gameplay::Keyboard::KEY_PG_DOWN;
     case VK_LEFT:
-        return gameplay::Input::KEY_LEFT_ARROW;
+        return gameplay::Keyboard::KEY_LEFT_ARROW;
     case VK_RIGHT:
-        return gameplay::Input::KEY_RIGHT_ARROW;
+        return gameplay::Keyboard::KEY_RIGHT_ARROW;
     case VK_UP:
-        return gameplay::Input::KEY_UP_ARROW;
+        return gameplay::Keyboard::KEY_UP_ARROW;
     case VK_DOWN:
-        return gameplay::Input::KEY_DOWN_ARROW;
+        return gameplay::Keyboard::KEY_DOWN_ARROW;
     case VK_NUMLOCK:
-        return gameplay::Input::KEY_NUM_LOCK;
+        return gameplay::Keyboard::KEY_NUM_LOCK;
     case VK_ADD:
-        return gameplay::Input::KEY_KP_PLUS;
+        return gameplay::Keyboard::KEY_KP_PLUS;
     case VK_SUBTRACT:
-        return gameplay::Input::KEY_KP_MINUS;
+        return gameplay::Keyboard::KEY_KP_MINUS;
     case VK_MULTIPLY:
-        return gameplay::Input::KEY_KP_MULTIPLY;
+        return gameplay::Keyboard::KEY_KP_MULTIPLY;
     case VK_DIVIDE:
-        return gameplay::Input::KEY_KP_DIVIDE;
+        return gameplay::Keyboard::KEY_KP_DIVIDE;
     case VK_NUMPAD7:
-        return gameplay::Input::KEY_KP_HOME;
+        return gameplay::Keyboard::KEY_KP_HOME;
     case VK_NUMPAD8:
-        return gameplay::Input::KEY_KP_UP;
+        return gameplay::Keyboard::KEY_KP_UP;
     case VK_NUMPAD9:
-        return gameplay::Input::KEY_KP_PG_UP;
+        return gameplay::Keyboard::KEY_KP_PG_UP;
     case VK_NUMPAD4:
-        return gameplay::Input::KEY_KP_LEFT;
+        return gameplay::Keyboard::KEY_KP_LEFT;
     case VK_NUMPAD5:
-        return gameplay::Input::KEY_KP_FIVE;
+        return gameplay::Keyboard::KEY_KP_FIVE;
     case VK_NUMPAD6:
-        return gameplay::Input::KEY_KP_RIGHT;
+        return gameplay::Keyboard::KEY_KP_RIGHT;
     case VK_NUMPAD1:
-        return gameplay::Input::KEY_KP_END;
+        return gameplay::Keyboard::KEY_KP_END;
     case VK_NUMPAD2:
-        return gameplay::Input::KEY_KP_DOWN;
+        return gameplay::Keyboard::KEY_KP_DOWN;
     case VK_NUMPAD3:
-        return gameplay::Input::KEY_KP_PG_DOWN;
+        return gameplay::Keyboard::KEY_KP_PG_DOWN;
     case VK_NUMPAD0:
-        return gameplay::Input::KEY_KP_INSERT;
+        return gameplay::Keyboard::KEY_KP_INSERT;
     case VK_DECIMAL:
-        return gameplay::Input::KEY_KP_DELETE;
+        return gameplay::Keyboard::KEY_KP_DELETE;
     case VK_F1:
-        return gameplay::Input::KEY_F1;
+        return gameplay::Keyboard::KEY_F1;
     case VK_F2:
-        return gameplay::Input::KEY_F2;
+        return gameplay::Keyboard::KEY_F2;
     case VK_F3:
-        return gameplay::Input::KEY_F3;
+        return gameplay::Keyboard::KEY_F3;
     case VK_F4:
-        return gameplay::Input::KEY_F4;
+        return gameplay::Keyboard::KEY_F4;
     case VK_F5:
-        return gameplay::Input::KEY_F5;
+        return gameplay::Keyboard::KEY_F5;
     case VK_F6:
-        return gameplay::Input::KEY_F6;
+        return gameplay::Keyboard::KEY_F6;
     case VK_F7:
-        return gameplay::Input::KEY_F7;
+        return gameplay::Keyboard::KEY_F7;
     case VK_F8:
-        return gameplay::Input::KEY_F8;
+        return gameplay::Keyboard::KEY_F8;
     case VK_F9:
-        return gameplay::Input::KEY_F9;
+        return gameplay::Keyboard::KEY_F9;
     case VK_F10:
-        return gameplay::Input::KEY_F10;
+        return gameplay::Keyboard::KEY_F10;
     case VK_F11:
-        return gameplay::Input::KEY_F11;
+        return gameplay::Keyboard::KEY_F11;
     case VK_F12:
-        return gameplay::Input::KEY_F12;
+        return gameplay::Keyboard::KEY_F12;
     case VK_SPACE:
-        return gameplay::Input::KEY_SPACE;
+        return gameplay::Keyboard::KEY_SPACE;
     case 0x30:
-        return shiftDown ? gameplay::Input::KEY_RIGHT_PARENTHESIS : gameplay::Input::KEY_ZERO;
+        return shiftDown ? gameplay::Keyboard::KEY_RIGHT_PARENTHESIS : gameplay::Keyboard::KEY_ZERO;
     case 0x31:
-        return shiftDown ? gameplay::Input::KEY_EXCLAM : gameplay::Input::KEY_ONE;
+        return shiftDown ? gameplay::Keyboard::KEY_EXCLAM : gameplay::Keyboard::KEY_ONE;
     case 0x32:
-        return shiftDown ? gameplay::Input::KEY_AT : gameplay::Input::KEY_TWO;
+        return shiftDown ? gameplay::Keyboard::KEY_AT : gameplay::Keyboard::KEY_TWO;
     case 0x33:
-        return shiftDown ? gameplay::Input::KEY_NUMBER : gameplay::Input::KEY_THREE;
+        return shiftDown ? gameplay::Keyboard::KEY_NUMBER : gameplay::Keyboard::KEY_THREE;
     case 0x34:
-        return shiftDown ? gameplay::Input::KEY_DOLLAR : gameplay::Input::KEY_FOUR;
+        return shiftDown ? gameplay::Keyboard::KEY_DOLLAR : gameplay::Keyboard::KEY_FOUR;
     case 0x35:
-        return shiftDown ? gameplay::Input::KEY_PERCENT : gameplay::Input::KEY_FIVE;
+        return shiftDown ? gameplay::Keyboard::KEY_PERCENT : gameplay::Keyboard::KEY_FIVE;
     case 0x36:
-        return shiftDown ? gameplay::Input::KEY_CIRCUMFLEX : gameplay::Input::KEY_SIX;
+        return shiftDown ? gameplay::Keyboard::KEY_CIRCUMFLEX : gameplay::Keyboard::KEY_SIX;
     case 0x37:
-        return shiftDown ? gameplay::Input::KEY_AMPERSAND : gameplay::Input::KEY_SEVEN;
+        return shiftDown ? gameplay::Keyboard::KEY_AMPERSAND : gameplay::Keyboard::KEY_SEVEN;
     case 0x38:
-        return shiftDown ? gameplay::Input::KEY_ASTERISK : gameplay::Input::KEY_EIGHT;
+        return shiftDown ? gameplay::Keyboard::KEY_ASTERISK : gameplay::Keyboard::KEY_EIGHT;
     case 0x39:
-        return shiftDown ? gameplay::Input::KEY_LEFT_PARENTHESIS : gameplay::Input::KEY_NINE;
+        return shiftDown ? gameplay::Keyboard::KEY_LEFT_PARENTHESIS : gameplay::Keyboard::KEY_NINE;
     case VK_OEM_PLUS:
-        return shiftDown ? gameplay::Input::KEY_EQUAL : gameplay::Input::KEY_PLUS;
+        return shiftDown ? gameplay::Keyboard::KEY_EQUAL : gameplay::Keyboard::KEY_PLUS;
     case VK_OEM_COMMA:
-        return shiftDown ? gameplay::Input::KEY_LESS_THAN : gameplay::Input::KEY_COMMA;
+        return shiftDown ? gameplay::Keyboard::KEY_LESS_THAN : gameplay::Keyboard::KEY_COMMA;
     case VK_OEM_MINUS:
-        return shiftDown ? gameplay::Input::KEY_UNDERSCORE : gameplay::Input::KEY_MINUS;
+        return shiftDown ? gameplay::Keyboard::KEY_UNDERSCORE : gameplay::Keyboard::KEY_MINUS;
     case VK_OEM_PERIOD:
-        return shiftDown ? gameplay::Input::KEY_GREATER_THAN : gameplay::Input::KEY_PERIOD;
+        return shiftDown ? gameplay::Keyboard::KEY_GREATER_THAN : gameplay::Keyboard::KEY_PERIOD;
     case VK_OEM_1:
-        return shiftDown ? gameplay::Input::KEY_COLON : gameplay::Input::KEY_SEMICOLON;
+        return shiftDown ? gameplay::Keyboard::KEY_COLON : gameplay::Keyboard::KEY_SEMICOLON;
     case VK_OEM_2:
-        return shiftDown ? gameplay::Input::KEY_QUESTION : gameplay::Input::KEY_SLASH;
+        return shiftDown ? gameplay::Keyboard::KEY_QUESTION : gameplay::Keyboard::KEY_SLASH;
     case VK_OEM_3:
-        return shiftDown ? gameplay::Input::KEY_GRAVE : gameplay::Input::KEY_TILDE;
+        return shiftDown ? gameplay::Keyboard::KEY_GRAVE : gameplay::Keyboard::KEY_TILDE;
     case VK_OEM_4:
-        return shiftDown ? gameplay::Input::KEY_LEFT_BRACE : gameplay::Input::KEY_LEFT_BRACKET;
+        return shiftDown ? gameplay::Keyboard::KEY_LEFT_BRACE : gameplay::Keyboard::KEY_LEFT_BRACKET;
     case VK_OEM_5:
-        return shiftDown ? gameplay::Input::KEY_BAR : gameplay::Input::KEY_BACK_SLASH;
+        return shiftDown ? gameplay::Keyboard::KEY_BAR : gameplay::Keyboard::KEY_BACK_SLASH;
     case VK_OEM_6:
-        return shiftDown ? gameplay::Input::KEY_RIGHT_BRACE : gameplay::Input::KEY_RIGHT_BRACKET;
+        return shiftDown ? gameplay::Keyboard::KEY_RIGHT_BRACE : gameplay::Keyboard::KEY_RIGHT_BRACKET;
     case VK_OEM_7:
-        return shiftDown ? gameplay::Input::KEY_QUOTE : gameplay::Input::KEY_APOSTROPHE;
+        return shiftDown ? gameplay::Keyboard::KEY_QUOTE : gameplay::Keyboard::KEY_APOSTROPHE;
     case 0x41:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_A : gameplay::Input::KEY_A;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_A : gameplay::Keyboard::KEY_A;
     case 0x42:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_B : gameplay::Input::KEY_B;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_B : gameplay::Keyboard::KEY_B;
     case 0x43:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_C : gameplay::Input::KEY_C;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_C : gameplay::Keyboard::KEY_C;
     case 0x44:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_D : gameplay::Input::KEY_D;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_D : gameplay::Keyboard::KEY_D;
     case 0x45:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_E : gameplay::Input::KEY_E;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_E : gameplay::Keyboard::KEY_E;
     case 0x46:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_F : gameplay::Input::KEY_F;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_F : gameplay::Keyboard::KEY_F;
     case 0x47:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_G : gameplay::Input::KEY_G;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_G : gameplay::Keyboard::KEY_G;
     case 0x48:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_H : gameplay::Input::KEY_H;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_H : gameplay::Keyboard::KEY_H;
     case 0x49:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_I : gameplay::Input::KEY_I;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_I : gameplay::Keyboard::KEY_I;
     case 0x4A:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_J : gameplay::Input::KEY_J;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_J : gameplay::Keyboard::KEY_J;
     case 0x4B:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_K : gameplay::Input::KEY_K;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_K : gameplay::Keyboard::KEY_K;
     case 0x4C:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_L : gameplay::Input::KEY_L;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_L : gameplay::Keyboard::KEY_L;
     case 0x4D:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_M : gameplay::Input::KEY_M;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_M : gameplay::Keyboard::KEY_M;
     case 0x4E:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_N : gameplay::Input::KEY_N;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_N : gameplay::Keyboard::KEY_N;
     case 0x4F:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_O : gameplay::Input::KEY_O;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_O : gameplay::Keyboard::KEY_O;
     case 0x50:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_P : gameplay::Input::KEY_P;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_P : gameplay::Keyboard::KEY_P;
     case 0x51:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_Q : gameplay::Input::KEY_Q;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_Q : gameplay::Keyboard::KEY_Q;
     case 0x52:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_R : gameplay::Input::KEY_R;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_R : gameplay::Keyboard::KEY_R;
     case 0x53:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_S : gameplay::Input::KEY_S;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_S : gameplay::Keyboard::KEY_S;
     case 0x54:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_T : gameplay::Input::KEY_T;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_T : gameplay::Keyboard::KEY_T;
     case 0x55:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_U : gameplay::Input::KEY_U;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_U : gameplay::Keyboard::KEY_U;
     case 0x56:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_V : gameplay::Input::KEY_V;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_V : gameplay::Keyboard::KEY_V;
     case 0x57:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_W : gameplay::Input::KEY_W;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_W : gameplay::Keyboard::KEY_W;
     case 0x58:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_X : gameplay::Input::KEY_X;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_X : gameplay::Keyboard::KEY_X;
     case 0x59:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_Y : gameplay::Input::KEY_Y;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_Y : gameplay::Keyboard::KEY_Y;
     case 0x5A:
-        return shiftDown ? gameplay::Input::KEY_CAPITAL_Z : gameplay::Input::KEY_Z;
+        return shiftDown ? gameplay::Keyboard::KEY_CAPITAL_Z : gameplay::Keyboard::KEY_Z;
     default:
-        return gameplay::Input::KEY_NONE;
+        return gameplay::Keyboard::KEY_NONE;
     }
 }
 
@@ -267,13 +267,13 @@ LRESULT CALLBACK __WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
         return 0;
 
     case WM_LBUTTONDOWN:
-        gameplay::Game::getInstance()->touch(LOWORD(lParam), HIWORD(lParam), gameplay::Input::TOUCHEVENT_PRESS);
+        gameplay::Game::getInstance()->touchEvent(gameplay::Touch::TOUCH_PRESS, LOWORD(lParam), HIWORD(lParam), 0);
         lMouseDown = true;
         return 0;
 
     case WM_LBUTTONUP:
         lMouseDown = false;
-        gameplay::Game::getInstance()->touch(LOWORD(lParam), HIWORD(lParam), gameplay::Input::TOUCHEVENT_RELEASE);
+        gameplay::Game::getInstance()->touchEvent(gameplay::Touch::TOUCH_RELEASE, LOWORD(lParam), HIWORD(lParam), 0);
         return 0;
 
     case WM_RBUTTONDOWN:
@@ -301,7 +301,7 @@ LRESULT CALLBACK __WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 
         if (lMouseDown)
         {
-            gameplay::Game::getInstance()->touch(LOWORD(lParam), HIWORD(lParam), gameplay::Input::TOUCHEVENT_MOVE);
+            gameplay::Game::getInstance()->touchEvent(gameplay::Touch::TOUCH_MOVE, LOWORD(lParam), HIWORD(lParam), 0);
             return 0;
         }
         else if (rMouseDown)
@@ -330,14 +330,14 @@ LRESULT CALLBACK __WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
         if (wParam == VK_LSHIFT || wParam == VK_RSHIFT)
             shiftDown = true;
 
-        gameplay::Game::getInstance()->keyPress(getGameplayInputKey(wParam, shiftDown), gameplay::Input::KEYEVENT_DOWN);
+        gameplay::Game::getInstance()->keyEvent(gameplay::Keyboard::KEY_PRESS, getKey(wParam, shiftDown));
         break;
 
     case WM_KEYUP:
         if (wParam == VK_LSHIFT || wParam == VK_RSHIFT)
             shiftDown = false;
 
-        gameplay::Game::getInstance()->keyPress(getGameplayInputKey(wParam, shiftDown), gameplay::Input::KEYEVENT_UP);
+        gameplay::Game::getInstance()->keyEvent(gameplay::Keyboard::KEY_RELEASE, getKey(wParam, shiftDown));
         break;
 
     case WM_SETFOCUS:
@@ -565,12 +565,16 @@ int Platform::getOrientationAngle()
     return 0;
 }
 
-bool Platform::isAccelerometerSupported()
+void Platform::setMultiTouch(bool enabled)
 {
-    return true;
 }
 
-void Platform::getAccelerometerPitchAndRoll(float* pitch, float* roll)
+bool Platform::isMultiTouch()
+{
+    return false;
+}
+
+void Platform::getAccelerometerValues(float* pitch, float* roll)
 {
     *pitch = __pitch;
     *roll = __roll;

gameplay/src/Touch.h

@@ -0,0 +1,35 @@
+#ifndef TOUCH_H_
+#define TOUCH_H_
+
+namespace gameplay
+{
+
+/**
+ * Touch event
+ */
+class Touch
+{
+public:
+
+    /**
+     * The touch event type.
+     */
+    enum TouchEvent
+    {
+        TOUCH_PRESS,
+        TOUCH_RELEASE,
+        TOUCH_MOVE
+    };
+
+
+private:
+
+    /**
+     * Constructor. Used internally.
+     */
+    Touch();
+};
+
+}
+
+#endif

gameplay/src/gameplay.h

@@ -2,7 +2,8 @@
 #include "Base.h"
 #include "Platform.h"
 #include "Game.h"
-#include "Input.h"
+#include "Keyboard.h"
+#include "Touch.h"
 #include "FileSystem.h"
 #include "Package.h"