macOS/iOS GamePad support (code included)

[EvilTrev]

Seemed to be missing, so I created a chunk of code that aims to work like the other entry code input interfaces. The GameController framework is required.

osx-info.plist:

	<key>GCSupportedGameControllers</key>
	<array>
		<dict>
			<key>ProfileName</key>
			<string>ExtendedGamepad</string>
		</dict>
	</array>
	<key>GCSupportsControllerUserInteraction</key>
	<true/>

entry_osx.cpp (add s_gcinput.update inside the autoreleasepool):

#import <GameController/GameController.h>

	struct GCInput
	{
		GCInput()
		{
			m_connected = false;
			bx::memSet(m_gamepadAxis, 0, sizeof(m_gamepadAxis) );
			bx::memSet(m_gamepadButton, 0, sizeof(m_gamepadButton) );

			// Deadzone values from xinput.h
			m_deadzone[GamepadAxis::LeftX ] =
			m_deadzone[GamepadAxis::LeftY ] = 7849;
			m_deadzone[GamepadAxis::RightX] =
			m_deadzone[GamepadAxis::RightY] = 8689;
			m_deadzone[GamepadAxis::LeftZ ] =
			m_deadzone[GamepadAxis::RightZ] = 30;
			
			bx::memSet(m_flip, 1, sizeof(m_flip) );
//			m_flip[GamepadAxis::LeftY ] =
//			m_flip[GamepadAxis::RightY] = -1;
		}
		
		bool filter(GamepadAxis::Enum _axis, int32_t _old, int32_t* _value)
		{
			const int32_t deadzone = m_deadzone[_axis];
			int32_t value = *_value;
			value = value > deadzone || value < -deadzone ? value : 0;
			*_value = value * m_flip[_axis];
			return _old != value;
		}

		void process(EventQueue& _eventQueue, WindowHandle& defaultWindow, GamepadHandle& handle, Key::Enum button, bool pressed)
		{
			if (m_gamepadButton[button] != pressed)
			{
				_eventQueue.postKeyEvent(defaultWindow, button, 0, pressed);
				m_gamepadButton[button] = pressed;
			}
		}

		void process(EventQueue& _eventQueue, WindowHandle& defaultWindow, GamepadHandle& handle, GamepadAxis::Enum _axis, int32_t _value)
		{
			if (m_gamepadAxis[_axis] != _value)
			{
				int32_t value = _value;
				if (filter(_axis, m_gamepadAxis[_axis], &value) )
				{
					_eventQueue.postAxisEvent(defaultWindow, handle, _axis, value);
				}
				m_gamepadAxis[_axis] = _value;
			}
		}
		
		void update(EventQueue& _eventQueue)
		{
			GamepadHandle handle = { 0 };			// TODO! Player index? Multiple controllers?
			WindowHandle defaultWindow = { 0 };
			
			// Is there an extended controller available?
			GCExtendedGamepad* gp = nil;
			if (@available(macOS 11.0, *) )
			{
				// Key off the "current" controller
				GCController* gpc = [GCController current];
				gp = (gpc != nil) ? [gpc extendedGamepad] : nil;
			}
			else
			{
				// Search for a decent controller to use (first extended controller)
				auto count = [[GCController controllers] count];
				for ( uint32_t i=0; i<count && gp == nil; ++i )
				{
					GCController* gpc = [GCController controllers][ i ];
					gp = (gpc != nil) ? [gpc extendedGamepad] : nil;
				}
			}
			
			// Did we find a controller to use?
			if ( gp != nil )
			{
				if ( !m_connected )
				{
					m_connected = true;
					_eventQueue.postGamepadEvent(defaultWindow, handle, m_connected);
				}
				
				// Process state of GamePad button
				process( _eventQueue, defaultWindow, handle, Key::GamepadUp, gp.dpad.up.pressed );
				process( _eventQueue, defaultWindow, handle, Key::GamepadDown, gp.dpad.down.pressed );
				process( _eventQueue, defaultWindow, handle, Key::GamepadLeft, gp.dpad.left.pressed );
				process( _eventQueue, defaultWindow, handle, Key::GamepadRight, gp.dpad.right.pressed );
				process( _eventQueue, defaultWindow, handle, Key::GamepadStart, gp.buttonMenu.pressed );
				process( _eventQueue, defaultWindow, handle, Key::GamepadBack, gp.buttonOptions.pressed );
				process( _eventQueue, defaultWindow, handle, Key::GamepadThumbL, gp.leftThumbstickButton.pressed );
				process( _eventQueue, defaultWindow, handle, Key::GamepadThumbR, gp.rightThumbstickButton.pressed );
				process( _eventQueue, defaultWindow, handle, Key::GamepadShoulderL, gp.leftShoulder.pressed );
				process( _eventQueue, defaultWindow, handle, Key::GamepadShoulderR, gp.rightShoulder.pressed );
				process( _eventQueue, defaultWindow, handle, Key::GamepadA, gp.buttonA.pressed );
				process( _eventQueue, defaultWindow, handle, Key::GamepadB, gp.buttonB.pressed );
				process( _eventQueue, defaultWindow, handle, Key::GamepadX, gp.buttonX.pressed );
				process( _eventQueue, defaultWindow, handle, Key::GamepadY, gp.buttonY.pressed );
				if (@available(macOS 11.0, *) )
				{
					process( _eventQueue, defaultWindow, handle, Key::GamepadGuide, gp.buttonHome.pressed );
				}

				// Process state of GamePad axis
				process( _eventQueue, defaultWindow, handle, GamepadAxis::LeftZ, (int32_t)( gp.leftTrigger.value * 32768 ) );
				process( _eventQueue, defaultWindow, handle, GamepadAxis::RightZ, (int32_t)( gp.rightTrigger.value * 32768 ) );
				process( _eventQueue, defaultWindow, handle, GamepadAxis::LeftX, (int32_t)( gp.leftThumbstick.xAxis.value * 32768 ) );
				process( _eventQueue, defaultWindow, handle, GamepadAxis::LeftY, (int32_t)( gp.leftThumbstick.yAxis.value * 32768 ) );
				process( _eventQueue, defaultWindow, handle, GamepadAxis::RightX, (int32_t)( gp.rightThumbstick.xAxis.value * 32768 ) );
				process( _eventQueue, defaultWindow, handle, GamepadAxis::RightY, (int32_t)( gp.rightThumbstick.yAxis.value * 32768 ) );
			}
			else if ( m_connected )
			{
				// No controller connected
				m_connected = false;
				_eventQueue.postGamepadEvent(defaultWindow, handle, m_connected);
				bx::memSet(m_gamepadAxis, 0, sizeof(m_gamepadAxis) );
				bx::memSet(m_gamepadButton, 0, sizeof(m_gamepadButton) );
			}
		}

		int32_t m_deadzone[GamepadAxis::Count];
		int32_t m_gamepadAxis[GamepadAxis::Count];
		int8_t m_flip[GamepadAxis::Count];
		bool m_gamepadButton[Key::Count];
		bool m_connected;
	};

	GCInput s_gcinput;

[bkaradzic]

It looks good, you should fix // TODO! Player index? Multiple controllers? and send PR.