csgo/cstrike15_src/inputsystem/joystick_osx.cpp

//===== Copyright (c) 1996-2005, Valve Corporation, All rights reserved. ======//
//
// Purpose: OSX Joystick implementation for inputsystem.dll
//
//===========================================================================//

#include <mach/mach.h>
#include <mach/mach_error.h>

/* For force feedback testing. */
#include "inputsystem.h"
#include "tier1/convar.h"


// NOTE: This has to be the last file included!
#include "tier0/memdbgon.h"

ConVar joy_axisbutton_threshold( "joy_axisbutton_threshold", "0.3", FCVAR_ARCHIVE, "Analog axis range before a button press is registered." );
ConVar joy_axis_deadzone( "joy_axis_deadzone", "0.2", FCVAR_ARCHIVE, "Dead zone near the zero point to not report movement." );

//-----------------------------------------------------------------------------
// Initialize all joysticks 
//-----------------------------------------------------------------------------
void CInputSystem::InitializeJoysticks( void ) 
{  
 	// assume no joystick
	m_nJoystickCount = 0; 

	// abort startup if user requests no joystick
	if ( CommandLine()->FindParm("-nojoy" ) ) 
		return; 
 
	IOReturn result = kIOReturnSuccess;
    mach_port_t masterPort = 0;
    io_iterator_t hidObjectIterator = 0;
    CFMutableDictionaryRef hidMatchDictionary = NULL;
		
    result = IOMasterPort( MACH_PORT_NULL, &masterPort);
    if ( kIOReturnSuccess != result ) 
	{
		DevMsg( 1, "joystick not found -- IOMasterPort error with bootstrap_port.\n");
        return;
    }
	
    hidMatchDictionary = IOServiceMatching(kIOHIDDeviceKey);
    if ( !hidMatchDictionary ) 
	{
        DevMsg( 1, "joystick not found -- Failed to get HID CFMutableDictionaryRef via IOServiceMatching.");
        return;
    }
	
    result = IOServiceGetMatchingServices( masterPort, hidMatchDictionary, &hidObjectIterator );
    if ( kIOReturnSuccess != result ) 
	{
        DevMsg( 1, "joystick not found -- Couldn't create a HID object iterator.");
        return ;
    }
	
    if ( !hidObjectIterator ) 	
	{  
		m_nJoystickCount = 0; 
        return;
    }
	
    io_object_t ioHIDDeviceObject = 0;	
    while ( ( ioHIDDeviceObject = IOIteratorNext(hidObjectIterator ) ) ) 
	{
		JoystickInfo_t &info = m_pJoystickInfo[m_nJoystickCount];
		info.m_pParent = this;
		info.m_bRemoved = false;
		info.m_Interface = NULL;
		info.m_FFInterface = 0;
		info.m_nButtonCount = 0;
		info.m_nFlags = 0;
		info.m_nAxisFlags = 0;
		info.m_bXBoxRumbleEnabled = false;

        // grab the device record
        if ( !HIDBuildDevice( ioHIDDeviceObject, info ) )
            continue;
		
        if ( FFIsForceFeedback(ioHIDDeviceObject) == FF_OK )
		{
            FFCreateDevice(ioHIDDeviceObject,&info.m_FFInterface);;
        } 
		else 
		{
            info.m_FFInterface = 0;
        }
		
		info.m_nDeviceId = m_nJoystickCount;
		info.m_nLastPolledButtons = 0;
		info.m_nLastPolledAxisButtons = 0;
		info.m_nLastPolledPOVState = 0;
		memset( info.m_pLastPolledAxes, 0, sizeof(info.m_pLastPolledAxes) );

		EnableJoystickInput( m_nJoystickCount, true );
		++m_nJoystickCount;		
    }

    result = IOObjectRelease(hidObjectIterator);
}

void HIDReportErrorNum(char *strError, long numError)
{
    DevMsg( 1, "%s", strError );
}

int ButtonSort(const void *a, const void *b)
{
	CInputSystem::OSXInputValue_t *left = (CInputSystem::OSXInputValue_t *)a;
	CInputSystem::OSXInputValue_t *right = (CInputSystem::OSXInputValue_t *)b;
	return left->m_Usage - right->m_Usage;
}


void CInputSystem::HIDSortJoystickButtons( JoystickInfo_t &info )
{
	qsort( info.m_Buttons, info.m_nButtonCount, sizeof(info.m_Buttons[0]), ButtonSort );
}


bool CInputSystem::HIDBuildDevice( io_object_t ioHIDDeviceObject, JoystickInfo_t &info )
{
	CFMutableDictionaryRef hidProperties = 0;
	kern_return_t result = IORegistryEntryCreateCFProperties( ioHIDDeviceObject, &hidProperties, kCFAllocatorDefault, kNilOptions);
	if ((result == KERN_SUCCESS) && hidProperties) 
	{
		if ( HIDCreateOpenDeviceInterface( ioHIDDeviceObject, info ) ) 
		{
			HIDGetDeviceInfo( ioHIDDeviceObject, hidProperties, info ); 
			HIDGetCollectionElements( hidProperties, info );
			HIDSortJoystickButtons( info );
		} 
		else 
			return false;

		CFRelease(hidProperties);
	} 
	else
		return false;
	
	// Filter device list to non-keyboard/mouse stuff 
	if ( info.usagePage != kHIDPage_GenericDesktop ||
		( ( info.usage != kHIDUsage_GD_Joystick &&
		  info.usage != kHIDUsage_GD_GamePad &&
		  info.usage != kHIDUsage_GD_MultiAxisController ) ) ) 
	{
		HIDDisposeDevice( info );
		return false;
	}
	return true;
}

static void HIDRemovalCallback(void *target, IOReturn result, void *refcon, void *sender)
{
    CInputSystem::JoystickInfo_t *joy = (CInputSystem::JoystickInfo_t *) refcon;
    joy->m_bRemoved = true;
}



/* Create and open an interface to device, required prior to extracting values or building queues.
 * Note: appliction now owns the device and must close and release it prior to exiting
 */

bool CInputSystem::HIDCreateOpenDeviceInterface( io_object_t hidDevice, JoystickInfo_t &info )
{
    IOReturn result = kIOReturnSuccess;
    HRESULT plugInResult = S_OK;
    SInt32 score = 0;
    IOCFPlugInInterface **ppPlugInInterface = NULL;
    if ( NULL == info.m_Interface ) 
	{
        result = IOCreatePlugInInterfaceForService(hidDevice, kIOHIDDeviceUserClientTypeID, kIOCFPlugInInterfaceID, &ppPlugInInterface, &score);
        if (kIOReturnSuccess == result) 
		{
            plugInResult = (*ppPlugInInterface)->QueryInterface(ppPlugInInterface, CFUUIDGetUUIDBytes(kIOHIDDeviceInterfaceID),(void **)&(info.m_Interface) );
            if ( plugInResult != S_OK )
                HIDReportErrorNum("Couldn’t query HID class device interface from plugInInterface", plugInResult);
			
			(*ppPlugInInterface)->Release(ppPlugInInterface);
        } 
		else
            HIDReportErrorNum("Failed to create **plugInInterface via IOCreatePlugInInterfaceForService.", result);
    }
	
    if ( info.m_Interface != NULL ) 
	{
        result = (*info.m_Interface)->open( info.m_Interface, 0);
        if ( result != kIOReturnSuccess )
		{
            HIDReportErrorNum("Failed to open pDevice->interface via open.", result);
		}
        else
		{
            (*info.m_Interface)->setRemovalCallback( info.m_Interface, HIDRemovalCallback, &info, this );
		}
    }
    return result == kIOReturnSuccess;
}


static void HIDTopLevelElementHandler(const void *value, void *parameter)
{
    CFTypeRef refCF = 0;
    if (CFGetTypeID(value) != CFDictionaryGetTypeID())
        return;
	
    refCF = CFDictionaryGetValue((CFDictionaryRef)value, CFSTR(kIOHIDElementUsagePageKey));
    if ( !CFNumberGetValue((CFNumberRef)refCF, kCFNumberLongType, &((CInputSystem::JoystickInfo_t *) parameter)->usagePage) )
        DevMsg( 1, "HIDTopLevelElementHandler CFNumberGetValue error retrieving pDevice->usagePage." );
	
    refCF = CFDictionaryGetValue((CFDictionaryRef)value, CFSTR(kIOHIDElementUsageKey));
    if ( !CFNumberGetValue((CFNumberRef)refCF, kCFNumberLongType, &((CInputSystem::JoystickInfo_t *) parameter)->usage) )
        DevMsg( 1, "HIDTopLevelElementHandler CFNumberGetValue error retrieving pDevice->usage." );
}


void CInputSystem::HIDGetDeviceInfo( io_object_t hidDevice, CFMutableDictionaryRef hidProperties, JoystickInfo_t &info )
{
    CFMutableDictionaryRef usbProperties = 0;
    io_registry_entry_t parent1, parent2;
	
    if ((KERN_SUCCESS == IORegistryEntryGetParentEntry(hidDevice, kIOServicePlane, &parent1))
        && (KERN_SUCCESS == IORegistryEntryGetParentEntry(parent1, kIOServicePlane, &parent2))
        && (KERN_SUCCESS == IORegistryEntryCreateCFProperties(parent2, &usbProperties, kCFAllocatorDefault, kNilOptions))) 
	{
		if ( usbProperties ) 
		{
			CFTypeRef refCF = 0;

			long vendorid = 0;
			long productid = 0;
			refCF = CFDictionaryGetValue((CFDictionaryRef)hidProperties, CFSTR(kIOHIDVendorIDKey) );
			if (refCF)
				CFNumberGetValue((CFNumberRef)refCF, kCFNumberLongType, &vendorid );
			refCF = CFDictionaryGetValue((CFDictionaryRef)hidProperties, CFSTR(kIOHIDProductIDKey) );
			if (refCF)
				CFNumberGetValue((CFNumberRef)refCF, kCFNumberLongType, &productid );
				
			if ( vendorid == 0x045e )
			{
				m_bXController = true; // microsoft gamepad, lets call it a 360 controller
			}
			
			/* get usage page and usage */
			refCF = CFDictionaryGetValue((CFDictionaryRef)hidProperties, CFSTR(kIOHIDPrimaryUsagePageKey) );
			if (refCF) 
			{
				if ( !CFNumberGetValue((CFNumberRef)refCF, kCFNumberLongType, &info.usagePage ) )
					DevMsg( 1, "CInputSystem::HIDGetDeviceInfo error retrieving pDevice->usagePage." );
				
				refCF =	CFDictionaryGetValue((CFDictionaryRef)hidProperties, CFSTR(kIOHIDPrimaryUsageKey));
				if (refCF)
					if (!CFNumberGetValue((CFNumberRef)refCF, kCFNumberLongType, &info.usage))
						DevMsg( 1, "CInputSystem::HIDGetDeviceInfo error retrieving pDevice->usage." );
			}
			
			if (NULL == refCF) 					
			{        
				CFTypeRef refCFTopElement = 0;
				refCFTopElement = CFDictionaryGetValue( (CFDictionaryRef)hidProperties, CFSTR(kIOHIDElementKey) );
				{
					CFRange range = { 0, CFArrayGetCount((CFArrayRef)refCFTopElement) };
					CFArrayApplyFunction( (CFArrayRef)refCFTopElement, range, HIDTopLevelElementHandler, &info );
				}
			}
		
	
			CFRelease( usbProperties );
		} 
		else
			DevMsg( 1, "CInputSystem::HIDGetDeviceInfo IORegistryEntryCreateCFProperties failed to create usbProperties." );
		
		if (kIOReturnSuccess != IOObjectRelease(parent2) )
			DevMsg( 1, "CInputSystem::HIDGetDeviceInfo IOObjectRelease error with parent2." );
		if (kIOReturnSuccess != IOObjectRelease(parent1))
			DevMsg( 1, "CInputSystem::HIDGetDeviceInfo IOObjectRelease error with parent1." );
	}
}


void CInputSystem::HIDGetElementInfo( CFTypeRef refElement, OSXInputValue_t &input )
{
    long number;
    CFTypeRef refType;
	
    refType = CFDictionaryGetValue( (CFDictionaryRef)refElement, CFSTR(kIOHIDElementCookieKey) );
    if ( refType && CFNumberGetValue( (CFNumberRef)refType, kCFNumberLongType, &number ) )
        input.m_Cookie = (int) number;
	
    refType = CFDictionaryGetValue( (CFDictionaryRef)refElement, CFSTR(kIOHIDElementMinKey) );
    if ( refType && CFNumberGetValue( (CFNumberRef)refType, kCFNumberLongType, &number ) )
	{
	        input.m_MinVal = input.m_MinReport = number;
		input.m_MaxVal = input.m_MaxReport = input.m_MinVal;
	}
	
    refType = CFDictionaryGetValue( (CFDictionaryRef)refElement, CFSTR(kIOHIDElementMaxKey) );
    if ( refType && CFNumberGetValue( (CFNumberRef)refType, kCFNumberLongType, &number ) )
	{
	        input.m_MaxVal = input.m_MaxReport = number;
	}
	input.m_bSet = true;
	input.m_RefElement = refElement;

	refType = CFDictionaryGetValue( (CFDictionaryRef)refElement, CFSTR(kIOHIDElementUsageKey) );
    if ( refType && CFNumberGetValue( (CFNumberRef)refType, kCFNumberLongType, &number ) )
	{
		input.m_Usage = number;
	}	
}


void CInputSystem::HIDAddElement(CFTypeRef refElement, JoystickInfo_t &info )
{
    long elementType, usagePage, usage;
    CFTypeRef refElementType = CFDictionaryGetValue( (CFDictionaryRef)refElement, CFSTR(kIOHIDElementTypeKey) );
    CFTypeRef refUsagePage = CFDictionaryGetValue( (CFDictionaryRef)refElement, CFSTR(kIOHIDElementUsagePageKey) );
    CFTypeRef refUsage = CFDictionaryGetValue( (CFDictionaryRef)refElement, CFSTR(kIOHIDElementUsageKey) );
	
    if ( refElementType && CFNumberGetValue( (CFNumberRef)refElementType, kCFNumberLongType, &elementType) ) 
	{
        if ( (elementType == kIOHIDElementTypeInput_Misc) || (elementType == kIOHIDElementTypeInput_Button) || (elementType == kIOHIDElementTypeInput_Axis) )
		{
            if ( refUsagePage && CFNumberGetValue( (CFNumberRef)refUsagePage, kCFNumberLongType, &usagePage )
				&& refUsage && CFNumberGetValue( (CFNumberRef)refUsage, kCFNumberLongType, &usage ) ) 
			{
                switch (usagePage) 
				{    
					case kHIDPage_GenericDesktop:
                    {
                        switch ( usage )
						{
							case kHIDUsage_GD_X:
								HIDGetElementInfo( refElement, info.m_xaxis );
								info.m_nAxisFlags |= 0x3;
								break;
							case kHIDUsage_GD_Y:
								HIDGetElementInfo( refElement, info.m_yaxis );
								info.m_nAxisFlags |= 0x3;
								break;
							case kHIDUsage_GD_Z:
								HIDGetElementInfo( refElement, info.m_zaxis );
								info.m_nAxisFlags |= 0x4;
								break;
							case kHIDUsage_GD_Rx:
								HIDGetElementInfo( refElement, info.m_uaxis );
								info.m_nAxisFlags |= 0x8;
								break;
							case kHIDUsage_GD_Ry:
								HIDGetElementInfo( refElement, info.m_raxis );
								info.m_nAxisFlags |= 0x10;
								break;
							case kHIDUsage_GD_Rz:
								HIDGetElementInfo( refElement, info.m_vaxis );
								info.m_nAxisFlags |= 0x20;
								break;
							case kHIDUsage_GD_Slider:
							case kHIDUsage_GD_Dial:
							case kHIDUsage_GD_Wheel:
								// unused
								break;
							case kHIDUsage_GD_Hatswitch:
								HIDGetElementInfo( refElement, info.m_POV );
								info.m_bHasPOVControl = true;
								break;
							default:
								break;
                        }
                    }
					break;
						
					case kHIDPage_Button:
						if ( info.m_nButtonCount < MAX_JOYSTICK_BUTTONS )
						{
							HIDGetElementInfo( refElement, info.m_Buttons[ info.m_nButtonCount ] );
							info.m_nButtonCount++;
						}
						break;
					default:
						break;
                }
            }
        } 
		else if (kIOHIDElementTypeCollection == elementType)
		{
            HIDGetCollectionElements((CFMutableDictionaryRef) refElement, info );
		}
    }
	
}



static void HIDGetElementsCFArrayHandler( const void *value, void *parameter )
{
    if ( CFGetTypeID(value) == CFDictionaryGetTypeID() )
	{
		CInputSystem::JoystickInfo_t *info = (CInputSystem::JoystickInfo_t *)parameter;
		if ( info )
			info->m_pParent->HIDAddElement( (CFTypeRef)value, *info );
	}
}


void CInputSystem::HIDGetElements( CFTypeRef refElementCurrent, JoystickInfo_t &info )
{
    CFTypeID type = CFGetTypeID(refElementCurrent);
    if (type == CFArrayGetTypeID()) 
	{
        CFRange range = { 0, CFArrayGetCount((CFArrayRef)refElementCurrent) };
        CFArrayApplyFunction((CFArrayRef)refElementCurrent, range, HIDGetElementsCFArrayHandler, &info );
    }
}


void CInputSystem::HIDGetCollectionElements( CFMutableDictionaryRef deviceProperties, JoystickInfo_t &info )
{
    CFTypeRef refElementTop = CFDictionaryGetValue((CFDictionaryRef)deviceProperties, CFSTR(kIOHIDElementKey));
    if (refElementTop)
        HIDGetElements( refElementTop, info );
}




void CInputSystem::HIDDisposeDevice( JoystickInfo_t &info )
{
    kern_return_t result = KERN_SUCCESS;
	if ( info.m_FFInterface )
	{
		if ( m_bXController && info.m_bXBoxRumbleEnabled )
		{
			info.m_bXBoxRumbleEnabled = false;
			FFEFFESCAPE escape;
			char c;
			c=0x00;
			escape.dwSize=sizeof(escape);
			escape.dwCommand=0x00;
			escape.cbInBuffer=sizeof(c);
			escape.lpvInBuffer=&c;
			escape.cbOutBuffer=0;
			escape.lpvOutBuffer=NULL;
			FFDeviceEscape( info.m_FFInterface ,&escape );
		}
		FFReleaseDevice( info.m_FFInterface );
	}
	
	result = (*info.m_Interface)->close( info.m_Interface );
	if ( result == kIOReturnNotOpen ) 
	{
		// wasn't open, what?
	} 
	else if ( result != kIOReturnSuccess)
	{
		HIDReportErrorNum( "Failed to close IOHIDDeviceInterface.", result );
	}
	
	result = (*info.m_Interface)->Release( info.m_Interface );
	if ( kIOReturnSuccess != result )
	{
		HIDReportErrorNum( "Failed to release IOHIDDeviceInterface.", result );
	}
}



	
	
	

//-----------------------------------------------------------------------------
//	Process the event
//-----------------------------------------------------------------------------
void CInputSystem::JoystickButtonEvent( ButtonCode_t button, int sample )
{
	// package the key
	if ( sample )
	{
		PostButtonPressedEvent( IE_ButtonPressed, m_nLastSampleTick, button, button );
	}
	else
	{
		PostButtonReleasedEvent( IE_ButtonReleased, m_nLastSampleTick, button, button );
	}
}


//-----------------------------------------------------------------------------
// Update the joystick button state
//-----------------------------------------------------------------------------
void CInputSystem::UpdateJoystickButtonState( int nJoystick )
{
	JoystickInfo_t &info = m_pJoystickInfo[nJoystick];

	int nButtons = 0;
	for ( int i = 0; i < info.m_nButtonCount; i++ )
	{
		int value = HIDGetElementValue( info, info.m_Buttons[i] ) - info.m_Buttons[i].m_MinVal;
		int mask = info.m_nLastPolledButtons & ( 1 << i );
		if ( !mask && !value ) // not pressed last time or this
			continue;
		
		ButtonCode_t code = (ButtonCode_t)JOYSTICK_BUTTON( nJoystick, i );
		if ( m_bXController )
		{
			// translate the xcontroller xpad buttons into the POV button presses we expect
			if ( i == 11 )
				code = KEY_XBUTTON_UP;
			if ( i == 12 )
				code = KEY_XBUTTON_DOWN;
			if ( i == 13 )
				code = KEY_XBUTTON_LEFT;
			if ( i == 14 )
				code = KEY_XBUTTON_RIGHT;
		}
				
		if ( value )
		{
			// down event
			JoystickButtonEvent( code, MAX_BUTTONSAMPLE );
		}
		else
		{
			// up event
			JoystickButtonEvent( code, 0 );
		}
	
		info.m_nLastPolledButtons &= ~( 1 << i );
		if ( value )
			info.m_nLastPolledButtons |= ( 1 << i );
	}
	
	// Analog axis buttons
	for ( int j = 0 ; j < MAX_JOYSTICK_AXES; ++j )
	{
		if ( ( info.m_nAxisFlags & (1 << j) ) == 0 )
			continue;
		
		// Positive side of the axis
		int mask = ( 1 << (j << 1) );
		ButtonCode_t code = JOYSTICK_AXIS_BUTTON( nJoystick, (j << 1) );
		float value = GetAnalogValue( JOYSTICK_AXIS( nJoystick, j ) );
		float minValue = joy_axisbutton_threshold.GetFloat();
		switch (j)
		{
			default:
			case 0:
				minValue *= info.m_xaxis.m_MaxVal;
				break;
			case 1:
				minValue *= info.m_yaxis.m_MaxVal;
				break;
			case 2:
				minValue *= info.m_zaxis.m_MaxVal;
				break;
			case 3:
				minValue *= info.m_raxis.m_MaxVal;
				break;
			case 4:
				minValue *= info.m_uaxis.m_MaxVal;
				break;				
			case 5:
				minValue *= info.m_vaxis.m_MaxVal;
				break;				
		}
		if ( j == 5 )
			code = KEY_XBUTTON_RTRIGGER; // left and right triggers go 0 to 255 under osx, so drag R axis over to z negative
		
		if ( value > minValue && !(info.m_nLastPolledAxisButtons & mask) )
		{
			info.m_nLastPolledAxisButtons |= mask;
			JoystickButtonEvent( code, MAX_BUTTONSAMPLE );
		}
		if ( value <= minValue && (info.m_nLastPolledAxisButtons & mask) )
		{
			info.m_nLastPolledAxisButtons &= ~mask;
			JoystickButtonEvent( code, 0 );
		}
		
		// Negative side of the axis
		mask <<= 1;
		code = (ButtonCode_t)( code + 1 );
		if ( value < -minValue && !(info.m_nLastPolledAxisButtons & mask) )
		{
			info.m_nLastPolledAxisButtons |= mask;
			JoystickButtonEvent( code, MAX_BUTTONSAMPLE );
		}
		if ( value >= -minValue && (info.m_nLastPolledAxisButtons & mask) )
		{
			info.m_nLastPolledAxisButtons &= ~mask;
			JoystickButtonEvent( code, 0 );
		}
	}	
}


int	CInputSystem::HIDGetElementValue( JoystickInfo_t &info, OSXInputValue_t &value )
{
	IOReturn result = kIOReturnSuccess;
	IOHIDEventStruct hidEvent;
	hidEvent.value = 0;
	
	if ( info.m_Interface != NULL )
	{
		result = (*info.m_Interface)->getElementValue( info.m_Interface, ( IOHIDElementCookie )value.m_Cookie, &hidEvent);
		if (kIOReturnSuccess == result) 
		{
			if ( hidEvent.value < value.m_MinReport )
				value.m_MinReport = hidEvent.value;
			if ( hidEvent.value > value.m_MaxReport )
				value.m_MaxReport = hidEvent.value;
		}
	}

	return hidEvent.value;
}
	
	
int CInputSystem::HIDScaledCalibratedValue( JoystickInfo_t &info, OSXInputValue_t &value )
{
	float deviceScale = value.m_MaxVal - value.m_MinVal;
	float readScale = value.m_MaxReport - value.m_MinReport;
	int joyvalue = HIDGetElementValue( info, value );
	if (readScale == 0)
		return joyvalue;
	else
		return ( (joyvalue - value.m_MinReport) * deviceScale / readScale) + value.m_MinVal;
}
	

//-----------------------------------------------------------------------------
// Purpose: Get raw joystick sample along axis
//-----------------------------------------------------------------------------
unsigned int CInputSystem::AxisValue( JoystickAxis_t axis, JoystickInfo_t &info )
{
	switch (axis)
	{
	case JOY_AXIS_X:
		return (unsigned int)HIDScaledCalibratedValue( info, info.m_xaxis );
	case JOY_AXIS_Y:
		return (unsigned int)HIDScaledCalibratedValue( info, info.m_yaxis );
	case JOY_AXIS_Z:
		return (unsigned int)HIDScaledCalibratedValue( info, info.m_zaxis );
	case JOY_AXIS_R:
		return (unsigned int)HIDScaledCalibratedValue( info, info.m_raxis );
	case JOY_AXIS_U:
		return (unsigned int)HIDScaledCalibratedValue( info, info.m_uaxis );
	case JOY_AXIS_V:
		return (unsigned int)HIDScaledCalibratedValue( info, info.m_vaxis );
	}
	// FIX: need to do some kind of error
	return (unsigned int)HIDScaledCalibratedValue( info, info.m_xaxis );
}


//-----------------------------------------------------------------------------
// Update the joystick POV control
//-----------------------------------------------------------------------------
void CInputSystem::UpdateJoystickPOVControl( int nJoystick )
{
	JoystickInfo_t &info = m_pJoystickInfo[nJoystick];

	if ( !info.m_bHasPOVControl )
		return;

	// convert POV information into 4 bits of state information
	// this avoids any potential problems related to moving from one
	// direction to another without going through the center position
	unsigned int povstate = 0;
		
	int range = ( info.m_POV.m_MaxVal - info.m_POV.m_MinVal + 1 );
	int value = HIDGetElementValue( info, info.m_POV ) - info.m_POV.m_MinVal;
	if (range == 4)         /* 4 position hatswitch - scale up value */
		value *= 2;
	else if (range != 8)    /* Neither a 4 nor 8 positions - fall back to default position (centered) */
		value = -1;
	switch (value) 
	{
		case 0:
			povstate |= 0x01;
			break;
		case 1:
			povstate |= 0x01;
			if ( info.m_bDiagonalPOVControlEnabled )
				povstate |= 0x02;
			break;
		case 2:
			povstate |= 0x02;
			break;
		case 3:
			povstate |= 0x02;
			if ( info.m_bDiagonalPOVControlEnabled )
				povstate |= 0x04;
			break;
		case 4:
			povstate |= 0x04;
			break;
		case 5:
			povstate |= 0x04;
			if ( info.m_bDiagonalPOVControlEnabled )
				povstate |= 0x08;
			break;
		case 6:
			povstate |= 0x08;
			break;
		case 7:
			povstate |= 0x08;
			if ( info.m_bDiagonalPOVControlEnabled )
				povstate |= 0x01;
			break;
		default:
			povstate = 0;
			break;
	}

	// determine which bits have changed and key an auxillary event for each change
	unsigned int buttons = povstate ^ info.m_nLastPolledPOVState;
	if ( buttons )
	{
		for ( int i = 0; i < JOYSTICK_POV_BUTTON_COUNT; ++i )
		{
			unsigned int mask = buttons & ( 1 << i );
			if ( !mask )
				continue;

			ButtonCode_t code = (ButtonCode_t)JOYSTICK_POV_BUTTON( nJoystick, i );

			if ( mask & povstate )
			{
				// Keydown on POV buttons
				JoystickButtonEvent( code, MAX_BUTTONSAMPLE );
			}
			else
			{
				// KeyUp on POV buttons
				JoystickButtonEvent( code, 0 );
			}
		}

		// Latch old values
		info.m_nLastPolledPOVState = povstate;
	}
}


//-----------------------------------------------------------------------------
// Purpose: Sample the joystick
//-----------------------------------------------------------------------------
void CInputSystem::PollJoystick( void )
{
	if ( !m_JoysticksEnabled.IsAnyFlagSet() )
		return;

	InputState_t &state = m_InputState[ m_bIsPolling ];
	for ( int i = 0; i < m_nJoystickCount; ++i )
	{
		if ( !m_JoysticksEnabled.IsFlagSet( 1 << i ) )
			continue;

		JoystickInfo_t &info = m_pJoystickInfo[i];
		if ( info.m_bRemoved ) 
			continue;

		// Poll joystick axes
		for ( int j = 0; j < MAX_JOYSTICK_AXES; ++j )
		{
			if ( ( info.m_nAxisFlags & ( 1 << j ) ) == 0 )
				continue;

			AnalogCode_t code = JOYSTICK_AXIS( i, j );
			int nValue = AxisValue( (JoystickAxis_t)j, info );
			float minValue = joy_axis_deadzone.GetFloat();
			switch (j)
			{
				default:
				case 0:
					minValue *= info.m_xaxis.m_MaxVal;
					break;
				case 1:
					minValue *= info.m_yaxis.m_MaxVal;
					break;
				case 2:
					minValue *= info.m_zaxis.m_MaxVal;
					break;
				case 3:
					minValue *= info.m_raxis.m_MaxVal;
					break;
				case 4:
					minValue *= info.m_uaxis.m_MaxVal;
					break;				
				case 5:
					minValue *= info.m_vaxis.m_MaxVal;
					break;				
			}
			
			if ( fabs(nValue) < minValue )
				nValue = 0;
			
			state.m_pAnalogDelta[ code ] = nValue - state.m_pAnalogValue[ code ];
			state.m_pAnalogValue[ code ] = nValue;
			
			if ( state.m_pAnalogDelta[ code ] != 0 )
			{
				//printf( "Joystick %i %d %d\n", code, state.m_pAnalogValue[ code ], state.m_pAnalogDelta[ code ] );
				PostEvent( IE_AnalogValueChanged, m_nLastSampleTick, code, state.m_pAnalogValue[ code ], state.m_pAnalogDelta[ code ] );
			}
		}

		UpdateJoystickButtonState( i );
		UpdateJoystickPOVControl( i );
	}
}


void CInputSystem::SetXDeviceRumble( float fLeftMotor, float fRightMotor, int userId )
{
	for ( int i = 0; i < m_nJoystickCount; ++i )
	{
		JoystickInfo_t &info = m_pJoystickInfo[i];
		if ( info.m_bRemoved || !info.m_FFInterface ) 
			continue;

		if ( m_bXController && !info.m_bXBoxRumbleEnabled )
		{
			info.m_bXBoxRumbleEnabled = true;
			FFEFFESCAPE escape;
			char c;
			c=0x01;
			escape.dwSize=sizeof(escape);
			escape.dwCommand=0x00;
			escape.cbInBuffer=sizeof(c);
			escape.lpvInBuffer=&c;
			escape.cbOutBuffer=0;
			escape.lpvOutBuffer=NULL;
			FFDeviceEscape( info.m_FFInterface ,&escape );
		}
		FFEFFESCAPE escape;
		char c[2];
			
		c[0]=(unsigned char) (fLeftMotor*255.0);
		c[1]=(unsigned char) (fRightMotor*255.0);
		escape.dwSize=sizeof(escape);
		escape.dwCommand=0x01;
		escape.cbInBuffer=sizeof(c);
		escape.lpvInBuffer=c;
		escape.cbOutBuffer=0;
		escape.lpvOutBuffer=NULL;
		FFDeviceEscape( info.m_FFInterface ,&escape );		
	}
}

// [will] BEGIN - These were copied from xcontroller.cpp for X360 button press emulation in OSX.
// We don't want to fully support XController on OSX, just enough to emulate Xbox Controller button presses.
// So instead of #defining out half of xcontroller.cpp for OSX, just copied it here.
#if !defined( _CERT )

#define XBX_MAX_BUTTONSAMPLE		32768
#define XBX_MAX_ANALOGSAMPLE		255
#define XBX_MAX_STICKSAMPLE_LEFT	32768
#define XBX_MAX_STICKSAMPLE_RIGHT	32767
#define XBX_MAX_STICKSAMPLE_DOWN	32768
#define XBX_MAX_STICKSAMPLE_UP		32767

#define XBX_STICK_SCALE_LEFT(x) 	( ( float )XBX_MAX_STICKSAMPLE_LEFT/( float )( XBX_MAX_STICKSAMPLE_LEFT-(x) ) )
#define XBX_STICK_SCALE_RIGHT(x) 	( ( float )XBX_MAX_STICKSAMPLE_RIGHT/( float )( XBX_MAX_STICKSAMPLE_RIGHT-(x) ) )
#define XBX_STICK_SCALE_DOWN(x) 	( ( float )XBX_MAX_STICKSAMPLE_DOWN/( float )( XBX_MAX_STICKSAMPLE_DOWN-(x) ) )
#define XBX_STICK_SCALE_UP(x)	 	( ( float )XBX_MAX_STICKSAMPLE_UP/( float )( XBX_MAX_STICKSAMPLE_UP-(x) ) )

#define XBX_STICK_SMALL_THRESHOLD	((int)( 0.20f * XBX_MAX_STICKSAMPLE_LEFT ))

// Threshold for counting analog movement as a button press
#define JOYSTICK_ANALOG_BUTTON_THRESHOLD	XBX_MAX_STICKSAMPLE_LEFT * 0.4f
//-----------------------------------------------------------------------------
//	Purpose: Post Xbox events, ignoring key repeats
//-----------------------------------------------------------------------------
void CInputSystem::PostXKeyEvent( int userId, xKey_t xKey, int nSample )
{
	AnalogCode_t	code	= ANALOG_CODE_LAST;
	float			value	= 0.f;

	// Map the physical controller slot to the split screen slot
#if defined( _GAMECONSOLE )
	int nMsgSlot = XBX_GetSlotByUserId( userId );
	#ifdef _PS3
	if ( ( XBX_GetNumGameUsers() <= 1 ) && !ps3_joy_ss.GetBool() )
	{
		// In PS3 START button identification mode START key notification
		// is replaced with INACTIVE_START notification that can identify
		// controller that pressed the button
		if ( ( xKey == XK_BUTTON_START ) && ( nMsgSlot < 0 )
			&& ( ( Plat_FloatTime() - g_ps3_flTimeStartButtonIdentificationMode ) < 0.5f ) )
		{
			xKey = XK_BUTTON_INACTIVE_START;
			nMsgSlot = userId;
		}
		else
		{
			// When we don't have splitscreen then any controller can
			// play and will be visible as controller #0
			nMsgSlot = 0;
		}
	}
	#endif
	if ( nMsgSlot < 0 )
	{
		// special case, that if you press start on a controller we've marked inactive, switch it to an
		// XK_BUTTON_INACTIVE_START which you can handle joins from inactive controllers
		if ( xKey == XK_BUTTON_START )
		{
			xKey = XK_BUTTON_INACTIVE_START;
			nMsgSlot = userId;
		}
		else
		{
			return; // We are not listening to this controller (not signed in and assigned)
		}
	}
#else //defined( _GAMECONSOLE )
	int nMsgSlot = userId;
#endif //defined( _GAMECONSOLE )

	int nSampleThreshold = 0;

	// Look for changes on the analog axes
	switch( xKey )
	{
	case XK_STICK1_LEFT:
	case XK_STICK1_RIGHT:
		{
			code = (AnalogCode_t)JOYSTICK_AXIS( nMsgSlot, JOY_AXIS_X );
			value = ( xKey == XK_STICK1_LEFT ) ? -nSample : nSample;
			nSampleThreshold = ( int )( JOYSTICK_ANALOG_BUTTON_THRESHOLD );
		}
		break;

	case XK_STICK1_UP:
	case XK_STICK1_DOWN:
		{
			code = (AnalogCode_t)JOYSTICK_AXIS( nMsgSlot, JOY_AXIS_Y );
			value = ( xKey == XK_STICK1_UP ) ? -nSample : nSample;
			nSampleThreshold = ( int )( JOYSTICK_ANALOG_BUTTON_THRESHOLD );
		}
		break;

	case XK_STICK2_LEFT:
	case XK_STICK2_RIGHT:
		{
			code = (AnalogCode_t)JOYSTICK_AXIS( nMsgSlot, JOY_AXIS_U );
			value = ( xKey == XK_STICK2_LEFT ) ? -nSample : nSample;
			nSampleThreshold = ( int )( JOYSTICK_ANALOG_BUTTON_THRESHOLD );
		}
		break;

	case XK_STICK2_UP:
	case XK_STICK2_DOWN:
		{
			code = (AnalogCode_t)JOYSTICK_AXIS( nMsgSlot, JOY_AXIS_R );
			value = ( xKey == XK_STICK2_UP ) ? -nSample : nSample;
			nSampleThreshold = ( int )( JOYSTICK_ANALOG_BUTTON_THRESHOLD );
		}
		break;
	}

	// Store the analog event
	if ( ANALOG_CODE_LAST != code )
	{
		InputState_t &state = m_InputState[ m_bIsPolling ];
		state.m_pAnalogDelta[ code ] = ( int )( value - state.m_pAnalogValue[ code ] );
		state.m_pAnalogValue[ code ] = ( int )value;
		if ( state.m_pAnalogDelta[ code ] != 0 )
		{
			PostEvent( IE_AnalogValueChanged, m_nLastSampleTick, code, ( int )value, state.m_pAnalogDelta[ code ] );
		}
	}

	// store the key
	m_appXKeys[userId][xKey].sample = nSample;
	if ( nSample > nSampleThreshold )
	{
		m_appXKeys[userId][xKey].repeats++;
	}
	else
	{
		m_appXKeys[userId][xKey].repeats = 0;
		nSample = 0;
	}

	if ( m_appXKeys[userId][xKey].repeats > 1 )
	{
		// application cannot handle streaming keys
		// first keypress is the only edge trigger
		return;
	}

	// package the key
	ButtonCode_t buttonCode = XKeyToButtonCode( nMsgSlot, xKey );
	if ( nSample )
	{
		PostButtonPressedEvent( IE_ButtonPressed, m_nLastSampleTick, buttonCode, buttonCode );

		// [dkorus] check whether we're trying to set the current controller
		if( ( buttonCode == KEY_XBUTTON_A || buttonCode == XK_BUTTON_START )
			&& m_setCurrentInputDeviceOnNextButtonPress )
		{
			if( IsInputDeviceConnected( INPUT_DEVICE_GAMEPAD ) )
			{
				SetCurrentInputDevice( INPUT_DEVICE_GAMEPAD );
				ConVarRef var( "joystick" );
				if( var.IsValid( ) )
					var.SetValue( 1 );
				m_setCurrentInputDeviceOnNextButtonPress = false;
			}
		}

	}
	else
	{
		PostButtonReleasedEvent( IE_ButtonReleased, m_nLastSampleTick, buttonCode, buttonCode );
	}
}
#endif // _CERT
// [will] END - These were copied from xcontroller.cpp for X360 button press emulation in OSX.