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

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

@@ -0,0 +1,133 @@
+// 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/
+
+#pragma once
+
+#include <string>
+#include <map>
+#include "CommonPaths.h"
+#include "Android/TextureLoader.h"
+
+namespace ButtonManager
+{
+	enum ButtonType
+	{
+		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:
+		GLuint m_tex;
+		ButtonType m_button;
+		ButtonState m_state;
+		float m_coords[8];
+	public:
+		Button(std::string filename, ButtonType button, float *coords)
+		{
+			m_tex = LoadPNG((std::string(DOLPHIN_DATA_DIR "/") + filename).c_str());
+			m_button = button;
+			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() { 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();
+}