Merge pull request #50 from nadiaholmquist/feature/basic-controller-input

Add basic controller input using the SDL2 GameController API

include/emulator.hpp

@@ -1,20 +1,19 @@
 #pragma once
 
-#include <filesystem>
-#include <fstream>
 #include <SDL.h>
 #include <glad/gl.h>
 
+#include <filesystem>
+#include <fstream>
+
+#include "PICA/gpu.hpp"
 #include "cpu.hpp"
 #include "crypto/aes_engine.hpp"
 #include "io_file.hpp"
 #include "memory.hpp"
 #include "opengl.hpp"
-#include "PICA/gpu.hpp"
 
-enum class ROMType {
-    None, ELF, NCSD
-};
+enum class ROMType { None, ELF, NCSD };
 
 class Emulator {
 	CPU cpu;
@@ -25,6 +24,14 @@ class Emulator {
 
 	SDL_Window* window;
 	SDL_GLContext glContext;
+	SDL_GameController* gameController;
+	int gameControllerID;
+
+	// Variables to keep track of whether the user is controlling the 3DS analog stick with their keyboard
+	// This is done so when a gamepad is connected, we won't automatically override the 3DS analog stick settings with the gamepad's state
+	// And so the user can still use the keyboard to control the analog
+	bool keyboardAnalogX = false;
+	bool keyboardAnalogY = false;
 
 	static constexpr u32 width = 400;
 	static constexpr u32 height = 240 * 2;  // * 2 because 2 screens
@@ -36,12 +43,18 @@ class Emulator {
 	std::ifstream loadedELF;
 	NCSD loadedNCSD;
 
-public:
+  public:
 	Emulator() : kernel(cpu, memory, gpu), cpu(memory, kernel), gpu(memory), memory(cpu.getTicksRef()) {
 		if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS) < 0) {
 			Helpers::panic("Failed to initialize SDL2");
 		}
 
+		// Make SDL use consistent positional button mapping
+		SDL_SetHint(SDL_HINT_GAMECONTROLLER_USE_BUTTON_LABELS, "0");
+		if (SDL_Init(SDL_INIT_GAMECONTROLLER) < 0) {
+			Helpers::warn("Failed to initialize SDL2 GameController: %s", SDL_GetError());
+		}
+
 		// Request OpenGL 4.1 Core (Max available on MacOS)
 		// MacOS gets mad if we don't explicitly demand a core profile
 		SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
@@ -54,15 +67,23 @@ public:
 		}
 
 		glContext = SDL_GL_CreateContext(window);
-
 		if (glContext == nullptr) {
 			Helpers::panic("OpenGL context creation failed: %s", SDL_GetError());
 		}
 
-        if(!gladLoadGL(reinterpret_cast<GLADloadfunc>(SDL_GL_GetProcAddress))) {
+		if (!gladLoadGL(reinterpret_cast<GLADloadfunc>(SDL_GL_GetProcAddress))) {
 			Helpers::panic("OpenGL init failed: %s", SDL_GetError());
 		}
 
+		if (SDL_WasInit(SDL_INIT_GAMECONTROLLER)) {
+			gameController = SDL_GameControllerOpen(0);
+
+			if (gameController != nullptr) {
+				SDL_Joystick* stick = SDL_GameControllerGetJoystick(gameController);
+				gameControllerID = SDL_JoystickInstanceID(stick);
+			}
+		}
+
 		reset();
 	}
 

include/services/hid.hpp

@@ -1,6 +1,7 @@
 #pragma once
 #include <array>
 #include <optional>
+
 #include "helpers.hpp"
 #include "kernel_types.hpp"
 #include "logger.hpp"
@@ -79,7 +80,7 @@ class HIDService {
 		*(T*)&sharedMem[offset] = value;
 	}
 
-public:
+  public:
 	HIDService(Memory& mem, Kernel& kernel) : mem(mem), kernel(kernel) {}
 	void reset();
 	void handleSyncRequest(u32 messagePointer);
@@ -87,6 +88,9 @@ public:
 	void pressKey(u32 mask) { newButtons |= mask; }
 	void releaseKey(u32 mask) { newButtons &= ~mask; }
 
+	s16 getCirclepadX() { return circlePadX; }
+	s16 getCirclepadY() { return circlePadY; }
+
 	void setCirclepadX(s16 x) {
 		circlePadX = x;
 

include/services/service_manager.hpp

@@ -90,8 +90,10 @@ class ServiceManager {
 	// Input function wrappers
 	void pressKey(u32 key) { hid.pressKey(key); }
 	void releaseKey(u32 key) { hid.releaseKey(key); }
-	void setCirclepadX(u16 x) { hid.setCirclepadX(x); }
-	void setCirclepadY(u16 y) { hid.setCirclepadY(y); }
+	s16 getCirclepadX() { return hid.getCirclepadX(); }
+	s16 getCirclepadY() { return hid.getCirclepadY(); }
+	void setCirclepadX(s16 x) { hid.setCirclepadX(x); }
+	void setCirclepadY(s16 y) { hid.setCirclepadY(y); }
 	void updateInputs(u64 currentTimestamp) { hid.updateInputs(currentTimestamp); }
 	void setTouchScreenPress(u16 x, u16 y) { hid.setTouchScreenPress(x, y); }
 	void releaseTouchScreen() { hid.releaseTouchScreen(); }

src/emulator.cpp

@@ -16,10 +16,7 @@ void Emulator::reset() {
 }
 
 void Emulator::step() {}
-
-void Emulator::render() {
-
-}
+void Emulator::render() {}
 
 void Emulator::run() {
 	while (running) {
@@ -42,6 +39,7 @@ void Emulator::run() {
 					printf("Bye :(\n");
 					running = false;
 					return;
+
 				case SDL_KEYDOWN:
 					switch (event.key.keysym.sym) {
 						case SDLK_l: srv.pressKey(Keys::A); break;
@@ -57,15 +55,31 @@ void Emulator::run() {
 						case SDLK_UP: srv.pressKey(Keys::Up); break;
 						case SDLK_DOWN: srv.pressKey(Keys::Down); break;
 
-                        case SDLK_w:     srv.setCirclepadY(0x9C);   break;
-                        case SDLK_a:     srv.setCirclepadX(-0x9C);  break;
-                        case SDLK_s:     srv.setCirclepadY(-0x9C);  break;
-                        case SDLK_d:     srv.setCirclepadX(0x9C);   break;
+						case SDLK_w:
+							srv.setCirclepadY(0x9C);
+							keyboardAnalogY = true;
+							break;
+
+						case SDLK_a:
+							srv.setCirclepadX(-0x9C);
+							keyboardAnalogX = true;
+							break;
+
+						case SDLK_s:
+							srv.setCirclepadY(-0x9C);
+							keyboardAnalogY = true;
+							break;
+
+						case SDLK_d:
+							srv.setCirclepadX(0x9C);
+							keyboardAnalogX = true;
+							break;
 
 						case SDLK_RETURN: srv.pressKey(Keys::Start); break;
 						case SDLK_BACKSPACE: srv.pressKey(Keys::Select); break;
 					}
 					break;
+
 				case SDL_KEYUP:
 					switch (event.key.keysym.sym) {
 						case SDLK_l: srv.releaseKey(Keys::A); break;
@@ -82,10 +96,17 @@ void Emulator::run() {
 						case SDLK_DOWN: srv.releaseKey(Keys::Down); break;
 
 						// Err this is probably not ideal
-                        case SDLK_w:     srv.setCirclepadY(0);  break;
-                        case SDLK_a:     srv.setCirclepadX(0);  break;
-                        case SDLK_s:     srv.setCirclepadY(0);  break;
-                        case SDLK_d:     srv.setCirclepadX(0);  break;
+						case SDLK_w:
+						case SDLK_s:
+							srv.setCirclepadY(0);
+							keyboardAnalogY = false;
+							break;
+
+						case SDLK_a:
+						case SDLK_d:
+							srv.setCirclepadX(0);
+							keyboardAnalogX = false;
+							break;
 
 						case SDLK_RETURN: srv.releaseKey(Keys::Start); break;
 						case SDLK_BACKSPACE: srv.releaseKey(Keys::Select); break;
@@ -104,8 +125,7 @@ void Emulator::run() {
 							u16 y_converted = static_cast<u16>(y) - 240;
 
 							srv.setTouchScreenPress(x_converted, y_converted);
-                        }
-                        else {
+						} else {
 							srv.releaseTouchScreen();
 						}
 					}
@@ -117,6 +137,70 @@ void Emulator::run() {
 						srv.releaseTouchScreen();
 					}
 					break;
+
+				case SDL_CONTROLLERDEVICEADDED:
+					if (gameController == nullptr) {
+						gameController = SDL_GameControllerOpen(event.cdevice.which);
+						gameControllerID = event.cdevice.which;
+					}
+					break;
+
+				case SDL_CONTROLLERDEVICEREMOVED:
+					if (event.cdevice.which == gameControllerID) {
+						SDL_GameControllerClose(gameController);
+						gameController = nullptr;
+						gameControllerID = 0;
+					}
+					break;
+
+				case SDL_CONTROLLERBUTTONUP:
+				case SDL_CONTROLLERBUTTONDOWN: {
+					u32 key = 0;
+
+					switch (event.cbutton.button) {
+						case SDL_CONTROLLER_BUTTON_A: key = Keys::B; break;
+						case SDL_CONTROLLER_BUTTON_B: key = Keys::A; break;
+						case SDL_CONTROLLER_BUTTON_X: key = Keys::Y; break;
+						case SDL_CONTROLLER_BUTTON_Y: key = Keys::X; break;
+						case SDL_CONTROLLER_BUTTON_LEFTSHOULDER: key = Keys::L; break;
+						case SDL_CONTROLLER_BUTTON_RIGHTSHOULDER: key = Keys::R; break;
+						case SDL_CONTROLLER_BUTTON_DPAD_LEFT: key = Keys::Left; break;
+						case SDL_CONTROLLER_BUTTON_DPAD_RIGHT: key = Keys::Right; break;
+						case SDL_CONTROLLER_BUTTON_DPAD_UP: key = Keys::Up; break;
+						case SDL_CONTROLLER_BUTTON_DPAD_DOWN: key = Keys::Down; break;
+						case SDL_CONTROLLER_BUTTON_BACK: key = Keys::Select; break;
+						case SDL_CONTROLLER_BUTTON_START: key = Keys::Start; break;
+					}
+
+					if (key != 0) {
+						if (event.cbutton.state == SDL_PRESSED) {
+							srv.pressKey(key);
+						} else {
+							srv.releaseKey(key);
+						}
+					}
+				}
+			}
+		}
+
+		if (gameController != nullptr) {
+			const s16 stickX = SDL_GameControllerGetAxis(gameController, SDL_CONTROLLER_AXIS_LEFTX);
+			const s16 stickY = SDL_GameControllerGetAxis(gameController, SDL_CONTROLLER_AXIS_LEFTY);
+			constexpr s16 deadzone = 3276;
+			constexpr s16 maxValue = 0x9C;
+			constexpr s16 div = 0x8000 / maxValue;
+
+			// Avoid overriding the keyboard's circlepad input
+			if (abs(stickX) < deadzone && !keyboardAnalogX) {
+				srv.setCirclepadX(0);
+			} else {
+				srv.setCirclepadX(stickX / div);
+			}
+
+			if (abs(stickY) < deadzone && !keyboardAnalogY) {
+				srv.setCirclepadY(0);
+			} else {
+				srv.setCirclepadY(-(stickY / div));
 			}
 		}
 
@@ -126,9 +210,7 @@ void Emulator::run() {
 	}
 }
 
-void Emulator::runFrame() {
-    cpu.runFrame();
-}
+void Emulator::runFrame() { cpu.runFrame(); }
 
 bool Emulator::loadROM(const std::filesystem::path& path) {
 	// Get path for saving files (AppData on Windows, /home/user/.local/share/ApplcationName on Linux, etc)
@@ -192,8 +274,9 @@ bool Emulator::loadELF(std::ifstream& file) {
 	loadedELF.seekg(0);
 
 	std::optional<u32> entrypoint = memory.loadELF(loadedELF);
-    if (!entrypoint.has_value())
+	if (!entrypoint.has_value()) {
 		return false;
+	}
 
 	cpu.setReg(15, entrypoint.value());  // Set initial PC
 	if (entrypoint.value() & 1) {