|
|
@@ -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);
|
Sean Paul Taylor