Gamepad support

Author: maxpoletaev

CHANGELOG.md

@@ -18,6 +18,7 @@
    in time in 5 second steps to quickly recover from mistakes. Can be used by
    pressing Ctrl+Z or ⌘+Z.
  * Game Genie codes support via the -gg flag.
+ * Gamepad support.
 
 ## v1.0.0 - 2024-01-26
 

README.md

@@ -87,6 +87,9 @@ follows. Multiplayer on a single keyboard is not supported.
 └───────────────────────────────────────┘
 ```
 
+If a gamepad is connected, it will likely be detected automatically and can be used
+instead of the keyboard. I tested it with a PS4 controller connected via Bluetooth.
+
 ### Zapper (Light Gun)
 
 Zapper is emulated using the mouse and can be used in games like Duck Hunt. Just 

ui/joystick.go

@@ -6,29 +6,107 @@ import (
 	"github.com/maxpoletaev/dendy/input"
 )
 
-var keyMap = map[int32]input.Button{
-	rl.KeyW:          input.ButtonUp,
-	rl.KeyS:          input.ButtonDown,
-	rl.KeyA:          input.ButtonLeft,
-	rl.KeyD:          input.ButtonRight,
-	rl.KeyK:          input.ButtonA,
-	rl.KeyJ:          input.ButtonB,
-	rl.KeyEnter:      input.ButtonStart,
-	rl.KeyRightShift: input.ButtonSelect,
+const (
+	turboRate      = 4
+	gamepadIndex   = 0
+	stickDeadzone  = 0.25
+	stickThreshold = 0.5
+)
+
+type keyMapping struct {
+	key    int32
+	button input.Button
+	turbo  bool
+}
+
+var keyboardMappings = []keyMapping{
+	{rl.KeyW, input.ButtonUp, false},
+	{rl.KeyS, input.ButtonDown, false},
+	{rl.KeyA, input.ButtonLeft, false},
+	{rl.KeyD, input.ButtonRight, false},
+	{rl.KeyJ, input.ButtonB, false},
+	{rl.KeyK, input.ButtonA, false},
+	{rl.KeyU, input.ButtonB, true},
+	{rl.KeyI, input.ButtonA, true},
+	{rl.KeyEnter, input.ButtonStart, false},
+	{rl.KeyRightShift, input.ButtonSelect, false},
+}
+
+var gamepadMappings = []keyMapping{
+	{rl.GamepadButtonLeftFaceUp, input.ButtonUp, false},
+	{rl.GamepadButtonLeftFaceDown, input.ButtonDown, false},
+	{rl.GamepadButtonLeftFaceLeft, input.ButtonLeft, false},
+	{rl.GamepadButtonLeftFaceRight, input.ButtonRight, false},
+	{rl.GamepadButtonRightFaceDown, input.ButtonA, false},
+	{rl.GamepadButtonRightFaceLeft, input.ButtonB, false},
+	{rl.GamepadButtonRightFaceRight, input.ButtonB, true},
+	{rl.GamepadButtonRightFaceUp, input.ButtonA, true},
+	{rl.GamepadButtonMiddleRight, input.ButtonStart, false},
+	{rl.GamepadButtonMiddleLeft, input.ButtonSelect, false},
 }
 
 func (w *Window) UpdateJoystick() {
 	if w.InputDelegate == nil {
 		return
 	}
 
+	w.turboCounter++
+	if w.turboCounter >= turboRate {
+		w.turboCounter = 0
+	}
+
 	var buttons uint8
 
-	for key, button := range keyMap {
-		if rl.IsKeyDown(key) {
-			buttons |= button
+	if w.gamepadAvailable {
+		buttons = readAnalogInput(buttons)
+
+		for _, km := range gamepadMappings {
+			if km.turbo && w.turboCounter != 0 {
+				continue
+			}
+			if rl.IsGamepadButtonDown(gamepadIndex, km.key) {
+				buttons |= km.button
+			}
+		}
+	}
+
+	for _, km := range keyboardMappings {
+		if km.turbo && w.turboCounter != 0 {
+			continue
+		}
+		if rl.IsKeyDown(km.key) {
+			buttons |= km.button
 		}
 	}
 
 	w.InputDelegate(buttons)
 }
+
+func readAnalogInput(buttons uint8) uint8 {
+	leftX := rl.GetGamepadAxisMovement(gamepadIndex, rl.GamepadAxisLeftX)
+	leftY := rl.GetGamepadAxisMovement(gamepadIndex, rl.GamepadAxisLeftY)
+
+	// Apply deadzone
+	if leftX < stickDeadzone && leftX > -stickDeadzone {
+		leftX = 0
+	}
+	if leftY < stickDeadzone && leftY > -stickDeadzone {
+		leftY = 0
+	}
+
+	// Convert analog input to digital directional buttons
+	if leftX < -stickThreshold {
+		buttons |= input.ButtonLeft
+	}
+	if leftX > stickThreshold {
+		buttons |= input.ButtonRight
+	}
+	if leftY < -stickThreshold {
+		buttons |= input.ButtonUp
+	}
+	if leftY > stickThreshold {
+		buttons |= input.ButtonDown
+	}
+
+	return buttons
+}

ui/window.go

@@ -27,14 +27,16 @@ type Window struct {
 	ShowFPS        bool
 	FPS            int
 
-	viewport    rl.RenderTexture2D
-	shader      *shaderFacade
-	remotePing  int64
-	shouldClose bool
-	grayscale   bool
-	scale       int
-	width       int
-	height      int
+	gamepadAvailable bool
+	viewport         rl.RenderTexture2D
+	shader           *shaderFacade
+	remotePing       int64
+	shouldClose      bool
+	grayscale        bool
+	scale            int
+	width            int
+	height           int
+	turboCounter     int
 }
 
 func CreateWindow(scale int, verbose bool) *Window {
@@ -51,12 +53,23 @@ func CreateWindow(scale int, verbose bool) *Window {
 	viewport := rl.LoadRenderTexture(ppu.FrameWidth, ppu.FrameHeight)
 	rl.SetTextureFilter(viewport.Texture, rl.FilterPoint)
 
-	return &Window{
+	w := &Window{
 		viewport: viewport,
 		scale:    scale,
 		width:    windowWidth,
 		height:   windowHeight,
 	}
+
+	// poll initial input events
+	rl.BeginDrawing()
+	rl.EndDrawing()
+
+	if rl.IsGamepadAvailable(gamepadIndex) {
+		log.Printf("[INFO] gamepad detected: %s", rl.GetGamepadName(gamepadIndex))
+		w.gamepadAvailable = true
+	}
+
+	return w
 }
 
 func (w *Window) EnableCRT() {
@@ -214,5 +227,10 @@ func (w *Window) HandleHotKeys() {
 		if w.RewindDelegate != nil {
 			w.RewindDelegate()
 		}
+
+	case w.gamepadAvailable && rl.IsGamepadButtonPressed(gamepadIndex, rl.GamepadButtonLeftTrigger1):
+		if w.RewindDelegate != nil {
+			w.RewindDelegate()
+		}
 	}
 }