[Android] Gamepad input. Refactor JNI native functions to all pull from a single class instead of everywhere willy-nilly

Source/Core/DolphinWX/CMakeLists.txt

@@ -92,6 +92,7 @@ if(wxWidgets_FOUND)
 else()
 	if(ANDROID)
 		set(SRCS Src/Android/TextureLoader.cpp
+			 Src/Android/ButtonManager.cpp
 			 Src/MainAndroid.cpp)
 	else()
 		set(SRCS Src/MainNoGUI.cpp)

Source/Core/DolphinWX/Src/Android/ButtonManager.cpp

@@ -0,0 +1,223 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+#include <vector>
+#include "GLInterface.h"
+#include "Android/TextureLoader.h"
+#include "Android/ButtonManager.h"
+
+extern void DrawButton(GLuint tex, float *coords);
+
+namespace ButtonManager
+{
+	std::vector<Button*> m_buttons;
+	std::map<std::string, InputDevice*> m_controllers;
+	// XXX: This needs to not be here so we can load the locations from file
+	// This will allow customizable button locations in the future
+	// These are the OpenGL on screen coordinates
+	float m_coords[][8] =	{ // X, Y, X, EY, EX, EY, EX, Y
+				{0.75f, -1.0f, 0.75f, -0.75f, 1.0f, -0.75f, 1.0f, -1.0f}, // A
+				{0.50f, -1.0f, 0.50f, -0.75f, 0.75f, -0.75f, 0.75f, -1.0f}, // B
+				{-0.10f, -1.0f, -0.10f, -0.80f, 0.10f, -0.80f, 0.10f, -1.0f}, // Start
+				};
+	const char *configStrings[] = {	"InputA",
+					"InputB",
+					"InputStart",
+					"InputX",
+					"InputY",
+					"InputZ",
+					"DPadUp",
+					"DPadDown",
+					"DPadLeft",
+					"DPadRight",
+					"MainUp",
+					"MainDown",
+					"MainLeft",
+					"MainRight",
+					"CStickUp",
+					"CStickDown",
+					"CStickLeft",
+					"CStickRight",
+					"InputL",
+					"InputR" };
+	const int configStringNum = 20;
+	
+	void AddBind(std::string dev, sBind *bind)
+	{
+		auto it = m_controllers.find(dev);
+		if (it != m_controllers.end())
+		{
+			it->second->AddBind(bind);
+			return;
+		}
+		m_controllers[dev] = new InputDevice(dev);
+		m_controllers[dev]->AddBind(bind);
+	}
+
+	void Init()
+	{
+		// Initialize our touchscreen buttons
+		m_buttons.push_back(new Button("ButtonA.png", BUTTON_A, m_coords[0]));
+		m_buttons.push_back(new Button("ButtonB.png", BUTTON_B, m_coords[1]));
+		m_buttons.push_back(new Button("ButtonStart.png", BUTTON_START, m_coords[2]));
+
+		// Init our controller bindings
+		IniFile ini;
+		ini.Load(File::GetUserPath(D_CONFIG_IDX) + std::string("Dolphin.ini"));
+		for (int a = 0; a < configStringNum; ++a)
+		{
+			BindType type;
+			int bindnum;
+			char dev[128];
+			bool hasbind = false;
+			char modifier = 0;
+			std::string value;
+			ini.Get("Android", configStrings[a], &value, "None");
+			if (value == "None")
+				continue;
+			if (std::string::npos != value.find("Axis"))
+			{
+				hasbind = true;
+				type = BIND_AXIS;
+				sscanf(value.c_str(), "Device '%[^\']'-Axis %d%c", dev, &bindnum, &modifier);	
+			}
+			else if (std::string::npos != value.find("Button"))  
+			{
+				hasbind = true;
+				type = BIND_BUTTON;
+				sscanf(value.c_str(), "Device '%[^\']'-Button %d", dev, &bindnum);
+			}
+			if (hasbind)
+				AddBind(std::string(dev), new sBind((ButtonType)a, type, bindnum, modifier == '-' ? -1.0f : 1.0f));
+		}
+
+	}
+	bool GetButtonPressed(ButtonType button)
+	{
+		bool pressed = false;
+		for (auto it = m_buttons.begin(); it != m_buttons.end(); ++it)
+			if ((*it)->GetButtonType() == button)
+				pressed = (*it)->Pressed();
+
+		for (auto it = m_controllers.begin(); it != m_controllers.end(); ++it)
+			pressed |= it->second->ButtonValue(button);
+
+		return pressed;
+	}
+	float GetAxisValue(ButtonType axis)
+	{
+		auto it = m_controllers.begin();
+		if (it == m_controllers.end())
+			return 0.0f;
+		return it->second->AxisValue(axis); 
+	}
+	void TouchEvent(int action, float x, float y)
+	{
+		// Actions
+		// 0 is press
+		// 1 is let go
+		// 2 is move
+		for (auto it = m_buttons.begin(); it != m_buttons.end(); ++it)
+		{
+			float *coords = (*it)->GetCoords();
+			if (	x >= coords[0] &&
+				x <= coords[4] &&
+				y >= coords[1] &&
+				y <= coords[3])
+			{
+				if (action == 0)
+					(*it)->SetState(BUTTON_PRESSED);
+				if (action == 1)
+					(*it)->SetState(BUTTON_RELEASED);
+				if (action == 2)
+					; // XXX: Be used later for analog stick
+			}
+		}
+	}
+
+	void GamepadEvent(std::string dev, int button, int action)
+	{
+		auto it = m_controllers.find(dev);
+		if (it != m_controllers.end())
+		{
+			it->second->PressEvent(button, action);
+			return;
+		}
+		m_controllers[dev] = new InputDevice(dev);
+		m_controllers[dev]->PressEvent(button, action);
+	}
+	void GamepadAxisEvent(std::string dev, int axis, float value)
+	{
+		auto it = m_controllers.find(dev);
+		if (it != m_controllers.end())
+		{
+			it->second->AxisEvent(axis, value);
+			return;
+		}
+		m_controllers[dev] = new InputDevice(dev);
+		m_controllers[dev]->AxisEvent(axis, value);
+	}
+	void Shutdown()
+	{
+		for(auto it = m_buttons.begin(); it != m_buttons.end(); ++it)
+			delete *it;
+		for (auto it = m_controllers.begin(); it != m_controllers.end(); ++it)
+			delete it->second;
+	}
+
+	void DrawButtons()
+	{
+		glEnable(GL_BLEND);
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+		for(auto it = m_buttons.begin(); it != m_buttons.end(); ++it)
+			DrawButton((*it)->GetTexture(), (*it)->GetCoords());	
+
+		glDisable(GL_BLEND);
+	}
+	
+	// InputDevice
+	void InputDevice::PressEvent(int button, int action)
+	{
+		m_buttons[button] = action == 0 ? true : false;
+	}
+	void InputDevice::AxisEvent(int axis, float value)
+	{
+		m_axises[axis] = value;
+	}
+	bool InputDevice::ButtonValue(ButtonType button)
+	{
+		auto it = m_binds.find(button);
+		if (it == m_binds.end())
+			return false;
+		if (it->second->m_bindtype == BIND_BUTTON)
+			return m_buttons[it->second->m_bind];
+		else
+			return AxisValue(button);
+	}
+	float InputDevice::AxisValue(ButtonType axis)
+	{
+		auto it = m_binds.find(axis);
+		if (it == m_binds.end())
+			return 0.0f;
+		if (it->second->m_bindtype == BIND_BUTTON)
+			return ButtonValue(axis);
+		else		
+			return m_axises[it->second->m_bind] * it->second->m_neg;
+	}
+	
+}

Source/Core/DolphinWX/Src/Android/ButtonManager.h

@@ -15,7 +15,10 @@
 // Official SVN repository and contact information can be found at
 // http://code.google.com/p/dolphin-emu/
 
+#pragma once
+
 #include <string>
+#include <map>
 #include "CommonPaths.h"
 #include "Android/TextureLoader.h"
 
@@ -26,12 +29,34 @@ namespace ButtonManager
 		BUTTON_A = 0,
 		BUTTON_B,
 		BUTTON_START,
+		BUTTON_X,
+		BUTTON_Y,
+		BUTTON_Z,
+		BUTTON_UP,
+		BUTTON_DOWN,
+		BUTTON_LEFT,
+		BUTTON_RIGHT,
+		STICK_MAIN_UP,
+		STICK_MAIN_DOWN,
+		STICK_MAIN_LEFT,
+		STICK_MAIN_RIGHT,
+		STICK_C_UP,
+		STICK_C_DOWN,
+		STICK_C_LEFT,
+		STICK_C_RIGHT,
+		TRIGGER_L,
+		TRIGGER_R
 	};
 	enum ButtonState
 	{
 		BUTTON_RELEASED = 0,
 		BUTTON_PRESSED = 1
 	};
+	enum BindType
+	{
+		BIND_BUTTON = 0,
+		BIND_AXIS
+	};
 	class Button
 	{
 	private:
@@ -47,17 +72,62 @@ namespace ButtonManager
 			memcpy(m_coords, coords, sizeof(float) * 8);
 			m_state = BUTTON_RELEASED;
 		}
+		Button(ButtonType button)
+		{
+			m_button = button;
+			m_state = BUTTON_RELEASED;
+		}
 		void SetState(ButtonState state) { m_state = state; }
 		bool Pressed() { return m_state == BUTTON_PRESSED; }
 		ButtonType GetButtonType() { return m_button; }
 		GLuint GetTexture() { return m_tex; }
 		float *GetCoords() { return m_coords; }
 			
-		~Button() { glDeleteTextures(1, &m_tex); }
+		~Button() { if(m_tex) glDeleteTextures(1, &m_tex); }
 	};
+
+	struct sBind
+	{
+		const ButtonType m_buttontype;
+		const BindType m_bindtype;
+		const int m_bind;
+		const float m_neg;
+		sBind(ButtonType buttontype, BindType bindtype, int bind, float neg) 
+			: m_buttontype(buttontype), m_bindtype(bindtype), m_bind(bind), m_neg(neg) 
+		{}
+	};
+	
+
+	class InputDevice
+	{
+	private:
+		std::string m_dev;
+		std::map<int, bool> m_buttons;
+		std::map<int, float> m_axises;
+		std::map<ButtonType, sBind*> m_binds;
+	public:
+		InputDevice(std::string dev)
+		{
+			m_dev = dev;
+		}
+		~InputDevice()
+		{
+			for (auto it = m_binds.begin(); it != m_binds.end(); ++it)
+			delete it->second;
+		}
+		void AddBind(sBind *bind) { m_binds[bind->m_buttontype] = bind; } 
+		void PressEvent(int button, int action);
+		void AxisEvent(int axis, float value);
+		bool ButtonValue(ButtonType button);
+		float AxisValue(ButtonType axis);
+	};
+
 	void Init();
 	void DrawButtons();
 	bool GetButtonPressed(ButtonType button);
+	float GetAxisValue(ButtonType axis);
 	void TouchEvent(int action, float x, float y);
+	void GamepadEvent(std::string dev, int button, int action);
+	void GamepadAxisEvent(std::string dev, int axis, float value);
 	void Shutdown();
 }

Source/Core/DolphinWX/Src/MainAndroid.cpp

@@ -200,26 +200,39 @@ std::string GetName(std::string filename)
 extern "C"
 {
 #endif
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeGLSurfaceView_UnPauseEmulation(JNIEnv *env, jobject obj)
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_UnPauseEmulation(JNIEnv *env, jobject obj)
 {
 	PowerPC::Start();
 }
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeGLSurfaceView_PauseEmulation(JNIEnv *env, jobject obj) 
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_PauseEmulation(JNIEnv *env, jobject obj) 
 {
 	PowerPC::Pause();
 }
 
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeGLSurfaceView_StopEmulation(JNIEnv *env, jobject obj) 
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_StopEmulation(JNIEnv *env, jobject obj) 
 {
 	PowerPC::Stop();
 }
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_DolphinEmulator_onTouchEvent(JNIEnv *env, jobject obj, jint Action, jfloat X, jfloat Y)
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_onTouchEvent(JNIEnv *env, jobject obj, jint Action, jfloat X, jfloat Y)
 {
 	ButtonManager::TouchEvent(Action, X, Y);
 }
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_onGamePadEvent(JNIEnv *env, jobject obj, jstring jDevice, jint Button, jint Action)
+{
+	const char *Device = env->GetStringUTFChars(jDevice, NULL);
+	std::string strDevice = std::string(Device);
+	ButtonManager::GamepadEvent(strDevice, Button, Action);
+	env->ReleaseStringUTFChars(jDevice, Device);
+}
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_onGamePadMoveEvent(JNIEnv *env, jobject obj, jstring jDevice, jint Axis, jfloat Value)
+{
+	const char *Device = env->GetStringUTFChars(jDevice, NULL);
+	std::string strDevice = std::string(Device);
+	ButtonManager::GamepadAxisEvent(strDevice, Axis, Value);
+	env->ReleaseStringUTFChars(jDevice, Device);
+}
 
-
-JNIEXPORT jintArray JNICALL Java_org_dolphinemu_dolphinemu_GameListItem_GetBanner(JNIEnv *env, jobject obj, jstring jFile)
+JNIEXPORT jintArray JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetBanner(JNIEnv *env, jobject obj, jstring jFile)
 {
 	const char *File = env->GetStringUTFChars(jFile, NULL);
 	jintArray Banner = env->NewIntArray(DVD_BANNER_WIDTH * DVD_BANNER_HEIGHT);
@@ -231,7 +244,7 @@ JNIEXPORT jintArray JNICALL Java_org_dolphinemu_dolphinemu_GameListItem_GetBanne
 	env->ReleaseStringUTFChars(jFile, File);
 	return Banner;
 }
-JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_GameListItem_GetTitle(JNIEnv *env, jobject obj, jstring jFile)
+JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetTitle(JNIEnv *env, jobject obj, jstring jFile)
 {
 	const char *File = env->GetStringUTFChars(jFile, NULL);
 	std::string Name = GetName(File);
@@ -241,41 +254,46 @@ JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_GameListItem_GetTitle(J
 	env->ReleaseStringUTFChars(jFile, File);
 	return env->NewStringUTF(Name.c_str());
 }
-JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_GameListView_GetConfig(JNIEnv *env, jobject obj, jstring jKey, jstring jValue, jstring jDefault)
+JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetConfig(JNIEnv *env, jobject obj, jstring jFile, jstring jKey, jstring jValue, jstring jDefault)
 {
 	IniFile ini;
-	ini.Load(File::GetUserPath(F_DOLPHINCONFIG_IDX));
+	const char *File = env->GetStringUTFChars(jFile, NULL);
 	const char *Key = env->GetStringUTFChars(jKey, NULL);
 	const char *Value = env->GetStringUTFChars(jValue, NULL);
 	const char *Default = env->GetStringUTFChars(jDefault, NULL);
 	
+	ini.Load(File::GetUserPath(D_CONFIG_IDX) + std::string(File));
 	std::string value;
 	
 	ini.Get(Key, Value, &value, Default);
-
+	
+	env->ReleaseStringUTFChars(jFile, File);
 	env->ReleaseStringUTFChars(jKey, Key);
 	env->ReleaseStringUTFChars(jValue, Value);
 	env->ReleaseStringUTFChars(jDefault, Default);
 
 	return env->NewStringUTF(value.c_str());
 }
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_GameListView_SetConfig(JNIEnv *env, jobject obj, jstring jKey, jstring jValue, jstring jDefault)
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetConfig(JNIEnv *env, jobject obj, jstring jFile, jstring jKey, jstring jValue, jstring jDefault)
 {
 	IniFile ini;
-	ini.Load(File::GetUserPath(F_DOLPHINCONFIG_IDX));
+	const char *File = env->GetStringUTFChars(jFile, NULL);
 	const char *Key = env->GetStringUTFChars(jKey, NULL);
 	const char *Value = env->GetStringUTFChars(jValue, NULL);
 	const char *Default = env->GetStringUTFChars(jDefault, NULL);
 	
-	ini.Set(Key, Value, Default);
-	ini.Save(File::GetUserPath(F_DOLPHINCONFIG_IDX));
+	ini.Load(File::GetUserPath(D_CONFIG_IDX) + std::string(File));
 
+	ini.Set(Key, Value, Default);
+	ini.Save(File::GetUserPath(D_CONFIG_IDX) + std::string(File));
+
+	env->ReleaseStringUTFChars(jFile, File);
 	env->ReleaseStringUTFChars(jKey, Key);
 	env->ReleaseStringUTFChars(jValue, Value);
 	env->ReleaseStringUTFChars(jDefault, Default);
 }
 
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeGLSurfaceView_main(JNIEnv *env, jobject obj, jstring jFile, jobject _surf, jint _width, jint _height)
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_Run(JNIEnv *env, jobject obj, jstring jFile, jobject _surf, jint _width, jint _height)
 {
 	surf = ANativeWindow_fromSurface(env, _surf);
 	g_width = (int)_width;
@@ -283,7 +301,6 @@ JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeGLSurfaceView_main(J
 
 	// Install our callbacks
 	OSD::AddCallback(OSD::OSD_INIT, OSDCallbacks, 0);
-	OSD::AddCallback(OSD::OSD_ONFRAME, OSDCallbacks, 1);
 	OSD::AddCallback(OSD::OSD_SHUTDOWN, OSDCallbacks, 2);
 
 	LogManager::Init();
@@ -292,6 +309,15 @@ JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeGLSurfaceView_main(J
 	VideoBackend::ActivateBackend(SConfig::GetInstance().m_LocalCoreStartupParameter.m_strVideoBackend);
 	WiimoteReal::LoadSettings();
 
+	// Load our Android specific settings
+	IniFile ini;
+	bool onscreencontrols = true;
+	ini.Load(File::GetUserPath(D_CONFIG_IDX) + std::string("Dolphin.ini"));
+	ini.Get("Android", "ScreenControls", &onscreencontrols, true);
+
+	if (onscreencontrols)
+		OSD::AddCallback(OSD::OSD_ONFRAME, OSDCallbacks, 1);
+
 	const char *File = env->GetStringUTFChars(jFile, NULL);
 	// No use running the loop when booting fails
 	if ( BootManager::BootCore( File ) )

Source/Core/InputCommon/CMakeLists.txt

@@ -23,8 +23,7 @@ elseif(X11_FOUND)
 				Src/ControllerInterface/Xlib/Xlib.cpp)
 elseif(ANDROID)
 	set(SRCS	${SRCS}
-				Src/ControllerInterface/Android/Android.cpp
-				Src/Android/ButtonManager.cpp)
+				Src/ControllerInterface/Android/Android.cpp)
 endif()
 
 add_library(inputcommon ${SRCS})

Source/Core/InputCommon/Src/Android/ButtonManager.cpp

@@ -1,92 +0,0 @@
-// Copyright (C) 2003 Dolphin Project.
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, version 2.0.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License 2.0 for more details.
-
-// A copy of the GPL 2.0 should have been included with the program.
-// If not, see http://www.gnu.org/licenses/
-
-// Official SVN repository and contact information can be found at
-// http://code.google.com/p/dolphin-emu/
-
-#include <vector>
-#include "GLInterface.h"
-#include "Android/TextureLoader.h"
-#include "Android/ButtonManager.h"
-
-extern void DrawButton(GLuint tex, float *coords);
-
-namespace ButtonManager
-{
-	std::vector<Button*> m_buttons;
-
-	// XXX: This needs to not be here so we can load the locations from file
-	// This will allow customizable button locations in the future
-	// These are the OpenGL on screen coordinates
-	float m_coords[][8] =	{ // X, Y, X, EY, EX, EY, EX, Y
-				{0.75f, -1.0f, 0.75f, -0.75f, 1.0f, -0.75f, 1.0f, -1.0f}, // A
-				{0.50f, -1.0f, 0.50f, -0.75f, 0.75f, -0.75f, 0.75f, -1.0f}, // B
-				{-0.10f, -1.0f, -0.10f, -0.80f, 0.10f, -0.80f, 0.10f, -1.0f}, // Start
-				};
-	
-	void Init()
-	{
-		// Initialize our buttons
-		m_buttons.push_back(new Button("ButtonA.png", BUTTON_A, m_coords[0]));
-		m_buttons.push_back(new Button("ButtonB.png", BUTTON_B, m_coords[1]));
-		m_buttons.push_back(new Button("ButtonStart.png", BUTTON_START, m_coords[2]));
-	}
-	bool GetButtonPressed(ButtonType button)
-	{
-		for (auto it = m_buttons.begin(); it != m_buttons.end(); ++it)
-			if ((*it)->GetButtonType() == button)
-				return (*it)->Pressed();
-		return false;
-	}
-	void TouchEvent(int action, float x, float y)
-	{
-		// Actions
-		// 0 is press
-		// 1 is let go
-		// 2 is move
-		for (auto it = m_buttons.begin(); it != m_buttons.end(); ++it)
-		{
-			float *coords = (*it)->GetCoords();
-			if (	x >= coords[0] &&
-				x <= coords[4] &&
-				y >= coords[1] &&
-				y <= coords[3])
-			{
-				if (action == 0)
-					(*it)->SetState(BUTTON_PRESSED);
-				if (action == 1)
-					(*it)->SetState(BUTTON_RELEASED);
-				if (action == 2)
-					; // XXX: Be used later for analog stick
-			}
-		}
-	}
-	void Shutdown()
-	{
-		for(auto it = m_buttons.begin(); it != m_buttons.end(); ++it)
-			delete *it;
-	}
-
-	void DrawButtons()
-	{
-		glEnable(GL_BLEND);
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
-		for(auto it = m_buttons.begin(); it != m_buttons.end(); ++it)
-			DrawButton((*it)->GetTexture(), (*it)->GetCoords());	
-
-		glDisable(GL_BLEND);
-	}
-
-}

Source/Core/InputCommon/Src/ControllerInterface/Android/Android.cpp

@@ -48,6 +48,20 @@ Touchscreen::Touchscreen()
 	AddInput(new Button(ButtonManager::BUTTON_A));
 	AddInput(new Button(ButtonManager::BUTTON_B));
 	AddInput(new Button(ButtonManager::BUTTON_START));
+	AddInput(new Button(ButtonManager::BUTTON_X));
+	AddInput(new Button(ButtonManager::BUTTON_Y));
+	AddInput(new Button(ButtonManager::BUTTON_Z));
+	AddInput(new Button(ButtonManager::BUTTON_UP));
+	AddInput(new Button(ButtonManager::BUTTON_DOWN));
+	AddInput(new Button(ButtonManager::BUTTON_LEFT));
+	AddInput(new Button(ButtonManager::BUTTON_RIGHT));
+	AddAnalogInputs(new Axis(ButtonManager::STICK_MAIN_LEFT), new Axis(ButtonManager::STICK_MAIN_RIGHT));
+	AddAnalogInputs(new Axis(ButtonManager::STICK_MAIN_UP), new Axis(ButtonManager::STICK_MAIN_DOWN));
+	AddAnalogInputs(new Axis(ButtonManager::STICK_C_UP), new Axis(ButtonManager::STICK_C_DOWN));
+	AddAnalogInputs(new Axis(ButtonManager::STICK_C_LEFT), new Axis(ButtonManager::STICK_C_RIGHT));
+	AddAnalogInputs(new Axis(ButtonManager::TRIGGER_L), new Axis(ButtonManager::TRIGGER_L));
+	AddAnalogInputs(new Axis(ButtonManager::TRIGGER_R), new Axis(ButtonManager::TRIGGER_R));
+
 }
 // Buttons and stuff
 
@@ -62,6 +76,17 @@ ControlState Touchscreen::Button::GetState() const
 {
 	return ButtonManager::GetButtonPressed(m_index);
 }
+std::string Touchscreen::Axis::GetName() const
+{
+	std::ostringstream ss;
+	ss << "Axis " << (int)m_index;
+	return ss.str();
+}
+
+ControlState Touchscreen::Axis::GetState() const
+{
+	return ButtonManager::GetAxisValue(m_index);
+}
 
 }
 }

Source/Core/InputCommon/Src/ControllerInterface/Android/Android.h

@@ -36,7 +36,16 @@ private:
 		Button(ButtonManager::ButtonType index) : m_index(index) {}
 		ControlState GetState() const;
 	private:
-		 const ButtonManager::ButtonType m_index;
+		const ButtonManager::ButtonType m_index;
+	};
+	class Axis : public Input
+	{
+	public:
+		std::string GetName() const;
+		Axis(ButtonManager::ButtonType index) : m_index(index) {}
+		ControlState GetState() const;
+	private:
+		const ButtonManager::ButtonType m_index;
 	};
 
 public: