macx_joy.m

/* Copyright (c) Dietmar Planitzer, 1998, 2002 */

/* This program is freely distributable without licensing fees 
   and is provided without guarantee or warrantee expressed or 
   implied. This program is -not- in the public domain. */

#import "macx_glut.h"
#import "GLUTView.h"
#import <IOKit/hid/IOHIDLib.h>
#import <Kernel/IOKit/hidsystem/IOHIDUsageTables.h>

struct _GLUTinputActionRec __glutInputActionArray[kNumJoystickActions];
static Boolean __glutJoystickList = false;

/* CENTRY */
void APIENTRY glutJoystickFunc(void (*func)(unsigned int buttonMask, int x, int y, int z), int pollInterval)
{
	GLUTAPI_DECLARATIONS
	__glutCollectInputDevicesOnce();
	__glutMatchHIDPrefsToDevices();
	if (!__glutJoystickList)
		__glutInitJoystickInput (NULL);
	GLUTAPI_BEGIN
	[__glutCurrentView	setJoystickCallback: func
                        pollInterval: ((NSTimeInterval) pollInterval) / 1000.0];
	GLUTAPI_END
}

void APIENTRY glutForceJoystickFunc(void)
{
   GLUTAPI_DECLARATIONS
   GLUTAPI_BEGIN
	[__glutCurrentView	processJoystick: NULL];
   GLUTAPI_END
}
/* ENDCENTRY */

short __glutGetJoystickNumButtons (void)
{
	short i, num = 0;
	if (!__glutJoystickList)
		__glutInitJoystickInput (NULL);
	for (i = kActionButton1; i < kNumJoystickActions; i++) // for all buttons
		if (__glutInputActionArray [i].pDevice != NULL) // if the device exists
			num++; // count
	return num;
}   

short __glutGetJoystickNumAxis (void)
{
	short i, num = 0;
	if (!__glutJoystickList)
	for (i = 0; i < kActionButton1; i++) // for all axis
		if (__glutInputActionArray [i].pDevice != NULL) // if the device exists
			num++; // count
	return num;
}   

struct _GLUTinputActionRec * __glutGetJoystickDeviceElement (short inputNum)
{
	if (!__glutJoystickList)
		__glutInitJoystickInput (NULL);
	return &__glutInputActionArray [inputNum];
}   

// check for attached devices (changes, reset globals if required for missing devices)
void __glutClearMissingDeviceJoystickInput (void) 
{
	short i;
	if (!__glutJoystickList)
		return;
	// assumes the list is updated
	for (i = 0; i < kNumJoystickActions; i++) {
		if (!__glutIsInputDeviceConnected(__glutInputActionArray[i].pDevice)) { // if we did not find the device
			__glutInputActionArray [i].pElement = NULL;
			__glutInputActionArray [i].pDevice = NULL;
			__glutInputActionArray [i].invertMul = 1; // not inverted
			__glutInputActionArray [i].value = 0;
		}
	}
}

void __glutFillEmptyJoystickInput (pRecDevice pDevice)
{
	short i;
   GLUTDeviceEnumerator	enumer;
	pRecDevice pSelDevice = NULL;
	pRecElement pElement = NULL;
	short selButtonCount = 0, selAxisCount = 0, currButton = 0;
   
   if (NULL == pDevice) { // no preferred device
		__glutGetInputDeviceEnumeratorOfClass(GLUT_JOYSTICK_DEVICE, &enumer);
		while((pDevice = __glutGetNextInputDevice(&enumer)) != NULL) { // while we have valid devices
			bool deviceSelect = NO;
			if (pDevice->axis >= 3) { // if device has at least 3 axis
				if ((selAxisCount < 3) || // previous device has less than 3 axis (select this device)
				    (pDevice->buttons > selButtonCount)) // select device has 3 or more axis and we have more buttons (select this device)
					deviceSelect = YES; 
				// else do not select (selected device has at least 3 axis and more buttons)
			} else if (((pDevice->axis == selAxisCount) && (pDevice->buttons > selButtonCount)) || // equal axis but more buttons (select this device)
					   (pDevice->axis == selAxisCount)) // more axis when current axis < 3
				deviceSelect = YES;
			if (YES == deviceSelect) { // if the number meet the min
				selAxisCount = pDevice->axis; // set selected number of axis
				selButtonCount = pDevice->buttons; // set selected number of buttons
				pSelDevice = pDevice; // set device
			}
		}
		pDevice = pSelDevice; // use a single device with the most axis
	}
	
	if (NULL == pDevice)
	{
		//we didn't find a suitable device, so leave things unassigned
		return;
	}

	__glutJoystickList = true; // set only if we found devices we like
   
	// prefer correct elements, then try any
	// look for x axis	
	if (NULL == __glutInputActionArray [kActionXAxis].pElement) { // if axis is empty
		pElement = HIDGetFirstDeviceElement (pDevice, kHIDElementTypeIO); // get first element
		while (pElement) { // for each element
			if ((kHIDPage_GenericDesktop == pElement->usagePage) && (kHIDUsage_GD_X == pElement->usage)) { // if it is the x axis
				__glutInputActionArray [kActionXAxis].pDevice = pDevice;
				__glutInputActionArray [kActionXAxis].pElement = pElement;
				// reset user min and max
				pElement->minReport = 0;
				pElement->maxReport = 0;
				break;
			}
			pElement = HIDGetNextDeviceElement (pElement, kHIDElementTypeIO); // get next element
		}
	}
	// look for y axis
	if (NULL == __glutInputActionArray [kActionYAxis].pElement) { // if axis is empty
		pElement = HIDGetFirstDeviceElement (pDevice, kHIDElementTypeIO); // get first element
		while (pElement) { // for each element
			if ((kHIDPage_GenericDesktop == pElement->usagePage) && (kHIDUsage_GD_Y == pElement->usage)) { // if it is the y axis
				__glutInputActionArray [kActionYAxis].pDevice = pDevice;
				__glutInputActionArray [kActionYAxis].pElement = pElement;
				// reset user min and max
				pElement->minReport = 0;
				pElement->maxReport = 0;
				break;
			}
			pElement = HIDGetNextDeviceElement (pElement, kHIDElementTypeIO); // get next element
		}
	}
	// look for z axis  (first as a z axis)
	if (NULL == __glutInputActionArray [kActionZAxis].pElement) { // if axis is empty
		pElement = HIDGetFirstDeviceElement (pDevice, kHIDElementTypeIO); // get first element
		while (pElement) { // for each element
			if ((kHIDPage_GenericDesktop == pElement->usagePage) && (kHIDUsage_GD_Z == pElement->usage)) { // if it is the y axis
				__glutInputActionArray [kActionZAxis].pDevice = pDevice;
				__glutInputActionArray [kActionZAxis].pElement = pElement;
				// reset user min and max
				pElement->minReport = 0;
				pElement->maxReport = 0;
				break;
			}
			pElement = HIDGetNextDeviceElement (pElement, kHIDElementTypeIO); // get next element
		}
	}
	// look for z axis as a z rotation (since most joysticks and gamepads are configured this way, thanks Windows...)
	if (NULL == __glutInputActionArray [kActionZAxis].pElement) { // if axis is empty
		pElement = HIDGetFirstDeviceElement (pDevice, kHIDElementTypeIO); // get first element
		while (pElement) { // for each element
			if ((kHIDPage_GenericDesktop == pElement->usagePage) && (kHIDUsage_GD_Rz == pElement->usage)) { // if it is the y axis
				__glutInputActionArray [kActionZAxis].pDevice = pDevice;
				__glutInputActionArray [kActionZAxis].pElement = pElement;
				// reset user min and max
				pElement->minReport = 0;
				pElement->maxReport = 0;
				break;
			}
			pElement = HIDGetNextDeviceElement (pElement, kHIDElementTypeIO); // get next element
		}
	}
	// for any not filled axis find any avialable (that is not already used)
	if (NULL == __glutInputActionArray [kActionXAxis].pElement) { // if axis is empty
		pElement = HIDGetFirstDeviceElement (pDevice, kHIDElementTypeIO); // get first element
		while (pElement) { // for each element
			if  ((kIOHIDElementTypeInput_Axis == pElement->type) || // if it is an axis or
					((kHIDPage_GenericDesktop == pElement->usagePage) && (kHIDUsage_GD_X <= pElement->usage) && (kHIDUsage_GD_Wheel >= pElement->usage))) { // it is an axis type usage
				if ((pElement != __glutInputActionArray [kActionYAxis].pElement) && (pElement != __glutInputActionArray [kActionZAxis].pElement)) { // not already used
					__glutInputActionArray [kActionXAxis].pDevice = pDevice;
					__glutInputActionArray [kActionXAxis].pElement = pElement;
					// reset user min and max
					pElement->minReport = 0;
					pElement->maxReport = 0;
					break;
				}
			}
			pElement = HIDGetNextDeviceElement (pElement, kHIDElementTypeIO); // get next element
		}
	}
	if (NULL == __glutInputActionArray [kActionYAxis].pElement) { // if axis is empty
		pElement = HIDGetFirstDeviceElement (pDevice, kHIDElementTypeIO); // get first element
		while (pElement) { // for each element
			if  ((kIOHIDElementTypeInput_Axis == pElement->type) || // if it is an axis or
					((kHIDPage_GenericDesktop == pElement->usagePage) && (kHIDUsage_GD_X <= pElement->usage) && (kHIDUsage_GD_Wheel >= pElement->usage))) { // it is an axis type usage
				if ((pElement != __glutInputActionArray [kActionXAxis].pElement) && (pElement != __glutInputActionArray [kActionZAxis].pElement)) { // not already used
					__glutInputActionArray [kActionYAxis].pDevice = pDevice;
					__glutInputActionArray [kActionYAxis].pElement = pElement;
					// reset user min and max
					pElement->minReport = 0;
					pElement->maxReport = 0;
					break;
				}
			}
			pElement = HIDGetNextDeviceElement (pElement, kHIDElementTypeIO); // get next element
		}
	}
	if (NULL == __glutInputActionArray [kActionZAxis].pElement) { // if axis is empty
		pElement = HIDGetFirstDeviceElement (pDevice, kHIDElementTypeIO); // get first element
		while (pElement) { // for each element
			if  ((kIOHIDElementTypeInput_Axis == pElement->type) || // if it is an axis or
					((kHIDPage_GenericDesktop == pElement->usagePage) && (kHIDUsage_GD_X <= pElement->usage) && (kHIDUsage_GD_Wheel >= pElement->usage))) { // it is an axis type usage
				if ((pElement != __glutInputActionArray [kActionXAxis].pElement) && (pElement != __glutInputActionArray [kActionYAxis].pElement)) { // not already used
					__glutInputActionArray [kActionZAxis].pDevice = pDevice;
					__glutInputActionArray [kActionZAxis].pElement = pElement;
					// reset user min and max
					pElement->minReport = 0;
					pElement->maxReport = 0;
					break;
				}
			}
			pElement = HIDGetNextDeviceElement (pElement, kHIDElementTypeIO); // get next element
		}
	}
	// find buttons (just fill them in order up to 32)
	pElement = HIDGetFirstDeviceElement (pDevice, kHIDElementTypeIO); // get first element
	while (pElement && (32 > currButton)) { // for each element and up to 32 buttons
		if  (kIOHIDElementTypeInput_Button == pElement->type) { // if it is a button
			Boolean found = false;
			short a;
			for (a = kActionButton1; a < kNumJoystickActions; a++) // check all buttons
				if (__glutInputActionArray [a].pElement == pElement) // is element used already
					found = true; // mark as such
			if (!found) { // if not used already
				while (NULL != __glutInputActionArray [kActionButton1 + currButton].pElement) // find first empty button
					currButton++; // advance until empty one since we can have a sparse array
				__glutInputActionArray [kActionButton1 + currButton].pDevice = pDevice; // assign button
				__glutInputActionArray [kActionButton1 + currButton].pElement = pElement;
			}
		}
		pElement = HIDGetNextDeviceElement (pElement, kHIDElementTypeIO); // get next element
	}
	// set device limits
	for (i = 0; i < kNumJoystickActions; i++)
	{
		if (__glutInputActionArray [i].pElement) {
			if (i < kActionButton1) {
				(__glutInputActionArray [i].pElement)->userMin = -1000;
				(__glutInputActionArray [i].pElement)->userMax = 1000;
			} else {
				(__glutInputActionArray [i].pElement)->userMin = 0;
				(__glutInputActionArray [i].pElement)->userMax = 1;
			}
		}
	}
	// all inputs will have same device
}

// assumes __glutCollectInputDevices already called
// check for atttached devices, set globals if required, enables/disblaes setup menu
void __glutInitJoystickInput (pRecDevice pDevice)
{
	int i;
	// zero all actions
	__glutJoystickList = false;
	for (i = 0; i < kNumJoystickActions; i++) {
		__glutInputActionArray [i].pElement = NULL;
		__glutInputActionArray [i].pDevice = NULL;
		__glutInputActionArray [i].invertMul = 1; // not inverted
		__glutInputActionArray [i].value = 0;
	}
	// find device with max (up to three) axis
	if (HIDCountDevices()) {
		__glutFillEmptyJoystickInput (pDevice);
	}
}

// return the device of first assigned input which will be the same for all inputs
pRecDevice __glutGetJoystickDevice (void)
{
	int i = 0;
	while ((NULL == __glutInputActionArray [i].pDevice) && (i < kNumJoystickActions))
		i++;
	if (i < kNumJoystickActions)
		return __glutInputActionArray [i].pDevice;
	else
		return NULL;
} 

// assumes __glutCollectInputDevices already called
// check for attached devices (changes, reset globals if required for missing devices)
// sets to device with at least 3 axis (or most if less) and most buttons is current device does not exist
void __glutUpdateJoystickInput (void) 
{
	if (!__glutJoystickList)
		__glutInitJoystickInput (NULL);
	else {
		// check for device ensure inputs are clear if device is not present
		if (NULL != __glutGetJoystickDevice()) // if we found a assigned input
			__glutClearMissingDeviceJoystickInput (); // check to ensure device is attached
		if (NULL == __glutGetJoystickDevice()) // if we cleared the input or if we found no assigned inputs
			__glutInitJoystickInput (NULL); // init the list
	}
}

// returns current polled values of first gamepad or joystick found
void __glutGetJoystickInput (int *pButtonMask, int *pX,  int *pY,  int *pZ)
{
    short a;
	*pButtonMask = 0;
	if (!__glutJoystickList) {
		*pX = 0;
		*pY = 0;
		*pZ = 0;
		return;
	}
    for (a = 0; a < kNumJoystickActions; a++)
    {
		__glutInputActionArray [a].value = 0;
		if (__glutInputActionArray [a].pDevice && __glutInputActionArray [a].pElement) { // handle device input
			__glutInputActionArray [a].value = HIDGetElementValue (__glutInputActionArray [a].pDevice, __glutInputActionArray [a].pElement);
			switch (a) {
				case kActionXAxis:
					*pX = __glutInputActionArray [a].invertMul * 
						  HIDScaleValue (__glutInputActionArray [a].value, __glutInputActionArray [a].pElement);
//						  HIDScaleValue (HIDCalibrateValue (__glutInputActionArray [a].value, __glutInputActionArray [a].pElement), __glutInputActionArray [a].pElement);
					break;
				case kActionYAxis:
					*pY = __glutInputActionArray [a].invertMul * 
					      HIDCalibrateValue (__glutInputActionArray [a].value, __glutInputActionArray [a].pElement);
//					      HIDScaleValue (HIDCalibrateValue (__glutInputActionArray [a].value, __glutInputActionArray [a].pElement), __glutInputActionArray [a].pElement);
					break;
				case kActionZAxis:
					*pZ = __glutInputActionArray [a].invertMul * 
						  HIDScaleValue (__glutInputActionArray [a].value, __glutInputActionArray [a].pElement);
//						  HIDScaleValue (HIDCalibrateValue (__glutInputActionArray [a].value, __glutInputActionArray [a].pElement), __glutInputActionArray [a].pElement);
					break;
				default:
					if (__glutInputActionArray [a].invertMul == 1)
//						*pButtonMask += HIDScaleValue (HIDCalibrateValue (__glutInputActionArray [a].value, __glutInputActionArray [a].pElement), __glutInputActionArray [a].pElement) << 
						*pButtonMask += HIDScaleValue (__glutInputActionArray [a].value, __glutInputActionArray [a].pElement) << 
									    (a - kActionButton1);
					else
//						*pButtonMask += (1 - HIDScaleValue (HIDCalibrateValue (__glutInputActionArray [a].value, __glutInputActionArray [a].pElement), __glutInputActionArray [a].pElement)) << 
						*pButtonMask += (1 - HIDScaleValue (__glutInputActionArray [a].value, __glutInputActionArray [a].pElement)) << 
									    (a - kActionButton1);
					break;
			}
		}
    }
}