Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Oct 7, 2010, 8:21:33 PM (14 years ago)
Author:
rgrieder
Message:

Updated OIS source files to its current SVN trunk (r26).

Location:
code/branches/ois_update/src/external/ois
Files:
3 added
29 edited

Legend:

Unmodified
Added
Removed
  • code/branches/ois_update/src/external/ois/OIS.h

    r5781 r7506  
    2929#include "OISKeyboard.h"
    3030#include "OISJoyStick.h"
     31#include "OISMultiTouch.h"
    3132#include "OISInputManager.h"
    3233#include "OISFactoryCreator.h"
  • code/branches/ois_update/src/external/ois/OISConfig.h

    r5781 r7506  
    7070@remarks
    7171        Build in support for Win32 XInput (Xbox 360 Controller)
    72 @notes
    73         Not Yet Implemented
    7472*/
    7573//#define OIS_WIN32_XINPUT_SUPPORT
  • code/branches/ois_update/src/external/ois/OISInputManager.cpp

    r5781 r7506  
    3737#elif defined OIS_APPLE_PLATFORM
    3838#  include "mac/MacInputManager.h"
     39#elif defined OIS_IPHONE_PLATFORM
     40#  include "iphone/iPhoneInputManager.h"
    3941#elif defined OIS_XBOX_PLATFORM
    4042#  include "xbox/XBoxInputManager.h"
     
    5961        m_wiiMoteSupport(0)
    6062{
     63    mFactories.clear();
     64    mFactoryObjects.clear();
    6165}
    6266
     
    111115#elif defined OIS_APPLE_PLATFORM
    112116        im = new MacInputManager();
     117#elif defined OIS_IPHONE_PLATFORM
     118        im = new iPhoneInputManager();
    113119#else
    114120        OIS_EXCEPT(E_General, "No platform library.. check build platform defines!");
  • code/branches/ois_update/src/external/ois/OISKeyboard.h

    r5781 r7506  
    184184        {
    185185        public:
    186                 KeyEvent( Object* obj, KeyCode kc, unsigned int txt ) : EventArg(obj), key(kc), text(txt) {}
     186                KeyEvent(Object* obj, KeyCode kc, unsigned int txt) : EventArg(obj), key(kc), text(txt) {}
    187187                virtual ~KeyEvent() {}
    188188
     
    201201        public:
    202202                virtual ~KeyListener() {}
    203                 virtual bool keyPressed( const KeyEvent &arg ) = 0;
    204                 virtual bool keyReleased( const KeyEvent &arg ) = 0;           
     203                virtual bool keyPressed(const KeyEvent &arg) = 0;
     204                virtual bool keyReleased(const KeyEvent &arg) = 0;             
    205205        };
    206206
     
    220220                        A KeyCode to check
    221221                */
    222                 virtual bool isKeyDown( KeyCode key ) const = 0;
     222                virtual bool isKeyDown(KeyCode key) const = 0;
    223223
    224224                /**
     
    229229                        Send a pointer to a class derived from KeyListener or 0 to clear the callback
    230230                */
    231                 virtual void setEventCallback( KeyListener *keyListener ) { mListener = keyListener;}
     231                virtual void setEventCallback(KeyListener *keyListener) { mListener = keyListener;}
    232232
    233233                /**
     
    254254                        Off, Unicode, Ascii
    255255                */
    256                 virtual void setTextTranslation( TextTranslationMode mode );
     256                virtual void setTextTranslation(TextTranslationMode mode);
    257257
    258258                /**
     
    272272                        The string as determined from the current locale
    273273                */
    274                 virtual const std::string& getAsString( KeyCode kc ) = 0;
     274                virtual const std::string& getAsString(KeyCode kc) = 0;
    275275
    276276                //! Enum of bit position of modifer
     
    286286                        Check modifier status
    287287                */
    288                 bool isModifierDown( Modifier mod ) const;
     288                bool isModifierDown(Modifier mod) const;
    289289
    290290                /**
     
    293293                        (in the form of 1 is down and 0 is up)
    294294                */
    295                 virtual void copyKeyStates( char keys[256] ) const = 0;
     295                virtual void copyKeyStates(char keys[256]) const = 0;
    296296               
    297297        protected:
  • code/branches/ois_update/src/external/ois/OISPrereqs.h

    r7163 r7506  
    7979#       endif
    8080#elif defined( __APPLE_CC__ ) // Apple OS X
    81 #       define OIS_APPLE_PLATFORM
    82 #       undef _OISExport
    83 #       define _OISExport __attribute__((visibility("default")))
     81    // Device                                       Simulator
     82#   if __IPHONE_OS_VERSION_MIN_REQUIRED >= 20201 || __IPHONE_OS_VERSION_MIN_REQUIRED >= 20000
     83//#   if __IPHONE_OS_VERSION_MIN_REQUIRED >= 30000 || __IPHONE_OS_VERSION_MIN_REQUIRED >= 30000
     84#       define OIS_IPHONE_PLATFORM
     85#   else
     86#       define OIS_APPLE_PLATFORM
     87#   endif
     88#   undef _OISExport
     89#   define _OISExport __attribute__((visibility("default")))
    8490#else //Probably Linux
    8591#       define OIS_LINUX_PLATFORM
     
    95101//-------------- Common Classes, Enums, and Typdef's -------------------------//
    96102#define OIS_VERSION_MAJOR 1
    97 #define OIS_VERSION_MINOR 2
     103#define OIS_VERSION_MINOR 4
    98104#define OIS_VERSION_PATCH 0
    99 #define OIS_VERSION_NAME "Smash"
     105#define OIS_VERSION_NAME "1.4.0"
    100106
    101107#define OIS_VERSION ((OIS_VERSION_MAJOR << 16) | (OIS_VERSION_MINOR << 8) | OIS_VERSION_PATCH)
     
    110116        class Mouse;
    111117        class JoyStick;
     118    class MultiTouch;
    112119        class KeyListener;
    113120        class MouseListener;
     121    class MultiTouchListener;
    114122        class JoyStickListener;
    115123        class Interface;
     
    130138    enum Type
    131139        {
    132                 OISUnknown   = 0,
    133                 OISKeyboard  = 1,
    134                 OISMouse     = 2,
    135                 OISJoyStick  = 3,
    136                 OISTablet    = 4
     140                OISUnknown       = 0,
     141                OISKeyboard      = 1,
     142                OISMouse         = 2,
     143                OISJoyStick      = 3,
     144                OISTablet        = 4,
     145                OISMultiTouch    = 5
    137146        };
    138147
  • code/branches/ois_update/src/external/ois/ReadMe.txt

    r5781 r7506  
    55The zlib/libpng License
    66
    7 Copyright (c) 2005-2007 Phillip Castaneda (pjcast -- www.wreckedgames.com)
     7Copyright (c) 2005-2010 Phillip Castaneda (pjcast -- www.wreckedgames.com)
    88
    99This software is provided 'as-is', without any express or implied warranty. In no
     
    4646Win32/
    4747        Contains Visual Studio .Net Solution Files
    48         Contains CodeBlocks + MinGW + StlPort project files for OIS
     48        Contains CodeBlocks project files for OIS
    4949       
    5050        ---- Dependencies ------------------------------------------------------
    5151        DirectInput 8
    52         Ogre & CEGUI 0.4.0 If building CEGUIOgre OIS Demo
    5352
    54         SDL/
    55                 A test bed for an OIS InputManager with SDL as the backend. Not recommended;
    56                 however, useful for platforms with non-native OIS ports for temporary use.
    5753
    5854Linux/
    5955        ---- Dependencies ------------------------------------------------------
    6056        X11
    61         Ogre (GLX Platform) & CEGUI 0.4.0 If building CEGUIOgre OIS Demo
    62         Newer Linux Kernel (2.6+ ?) for Event API - else, use --disable-joyevents
     57        Newer Linux Kernel (2.6+ ?) for Event API
    6358
    6459        Steps to build on Linux:
     
    6964        ---- Configure build options --------------------------------------------
    7065        ./configure --help              --- List all configure options
    71         ./configure --disable-ogre      --- Disables CEGUIOgre ActionMapping Demo
    72         ./configure --disable-joyevents --- Uses /dev/input/jsX instead of
    73                                             /dev/input/eventX
     66
    7467
    7568LinuxCB/
     
    8073
    8174Mac/
    82        
    83         XCode-1.5/
    84                 Non-complete native OIS port.
    85 
    8675        XCode-2.2/
    87                 Working, complete, OIS port to OSX using SDL as a backend.
     76                Working, mostly complete OSX vackend.
  • code/branches/ois_update/src/external/ois/VERSION

    r5781 r7506  
    1 OIS v1_2 CVS updated on 2009/01/24
    2 Note that this is not CVS HEAD, but v1_2 branch!
    3 
     1OIS SVN trunk updated on 2010/10/07 (revision 26)
     2https://wgois.svn.sourceforge.net/svnroot/wgois/ois/trunk/
  • code/branches/ois_update/src/external/ois/changes_orxonox.diff

    r7163 r7506  
    3737+++ win32/Win32ForceFeedback.cpp
    3838@@ -25,7 +25,7 @@
    39  #include <Math.h>
     39 #include <math.h>
    4040 
    4141 // 0 = No trace; 1 = Important traces; 2 = Debug traces
  • code/branches/ois_update/src/external/ois/linux/LinuxInputManager.cpp

    r5781 r7506  
    4040        hideMouse = true;
    4141        mGrabs = true;
    42         useXRepeat = false;
    4342        keyboardUsed = mouseUsed = false;
    4443
     
    7473
    7574        //--------- Keyboard Settings ------------//
    76         i = paramList.find("XAutoRepeatOn");
    77         if( i != paramList.end() )
    78                 if( i->second == "true" )
    79                         useXRepeat = true;
    80 
    8175        i = paramList.find("x11_keyboard_grab");
    8276        if( i != paramList.end() )
     
    172166        {
    173167                if( keyboardUsed == false )
    174                         obj = new LinuxKeyboard(this, bufferMode, grabKeyboard, useXRepeat);
     168                        obj = new LinuxKeyboard(this, bufferMode, grabKeyboard);
    175169                break;
    176170        }
  • code/branches/ois_update/src/external/ois/linux/LinuxInputManager.h

    r5781 r7506  
    101101                bool mGrabs;
    102102                bool hideMouse;
    103 
    104                 //! By default, keyboard disables XRepeatRate
    105                 bool useXRepeat;
    106103        };
    107104}
  • code/branches/ois_update/src/external/ois/linux/LinuxJoyStickEvents.cpp

    r5781 r7506  
    9696        //We are in non blocking mode - we just read once, and try to fill up buffer
    9797        input_event js[JOY_BUFFERSIZE];
    98         int ret = read(mJoyStick, &js, sizeof(struct input_event) * JOY_BUFFERSIZE);
    99         if( ret <= 0 )
    100                 return;
    101 
    102         //Determine how many whole events re read up
    103         ret /= sizeof(struct input_event);
    104         for(int i = 0; i < ret; ++i)
     98        while(true)
    10599        {
    106                 switch(js[i].type)
     100                int ret = read(mJoyStick, &js, sizeof(struct input_event) * JOY_BUFFERSIZE);
     101        if( ret < 0 )
     102                        break;
     103
     104                //Determine how many whole events re read up
     105                ret /= sizeof(struct input_event);
     106                for(int i = 0; i < ret; ++i)
    107107                {
    108                 case EV_KEY:  //Button
    109                 {
    110                         int button = mButtonMap[js[i].code];
    111 
    112                         #ifdef OIS_LINUX_JOY_DEBUG
    113                           cout << "\nButton Code: " << js[i].code << ", OIS Value: " << button << endl;
    114                         #endif
    115 
    116                         //Check to see whether push or released event...
    117                         if(js[i].value)
    118                         {
    119                                 mState.mButtons[button] = true;
    120                                 if( mBuffered && mListener )
    121                                         if(!mListener->buttonPressed(JoyStickEvent(this,mState), button)) return;
    122                         }
    123                         else
    124                         {
    125                                 mState.mButtons[button] = false;
    126                                 if( mBuffered && mListener )
    127                                         if(!mListener->buttonReleased(JoyStickEvent(this,mState), button)) return;
    128                         }
    129                         break;
    130                 }
    131 
    132                 case EV_ABS:  //Absolute Axis
    133                 {
    134                         //A Stick (BrakeDefine is the highest possible Axis)
    135                         if( js[i].code <= ABS_BRAKE )
    136                         {
    137                                 int axis = mAxisMap[js[i].code];
    138                                 assert( axis < 32 && "Too many axes (Max supported is 32). Report this to OIS forums!" );
    139 
    140                                 axisMoved[axis] = true;
    141 
    142                                 //check for rescaling:
    143                                 if( mRanges[axis].min == JoyStick::MIN_AXIS && mRanges[axis].max != JoyStick::MAX_AXIS )
    144                                 {       //Scale is perfect
    145                                         mState.mAxes[axis].abs = js[i].value;
     108                        switch(js[i].type)
     109                        {
     110                        case EV_KEY:  //Button
     111                        {
     112                                int button = mButtonMap[js[i].code];
     113
     114                                #ifdef OIS_LINUX_JOY_DEBUG
     115                                  cout << "\nButton Code: " << js[i].code << ", OIS Value: " << button << endl;
     116                                #endif
     117
     118                                //Check to see whether push or released event...
     119                                if(js[i].value)
     120                                {
     121                                        mState.mButtons[button] = true;
     122                                        if( mBuffered && mListener )
     123                                                if(!mListener->buttonPressed(JoyStickEvent(this,mState), button)) return;
    146124                                }
    147125                                else
    148                                 {       //Rescale
    149                                         float proportion = (float)(js[i].value-mRanges[axis].max)/(float)(mRanges[axis].min-mRanges[axis].max);
    150                                         mState.mAxes[axis].abs = (int)(32767.0f - (65535.0f * proportion));
     126                                {
     127                                        mState.mButtons[button] = false;
     128                                        if( mBuffered && mListener )
     129                                                if(!mListener->buttonReleased(JoyStickEvent(this,mState), button)) return;
    151130                                }
    152                         }
    153                         else if( js[i].code <= ABS_HAT3Y ) //A POV - Max four POVs allowed
    154                         {
    155                                 //Normalise the POV to between 0-7
    156                                 //Even is X Axis, Odd is Y Axis
    157                                 unsigned char LinuxPovNumber = js[i].code - 16;
    158                                 short OIS_POVIndex = POV_MASK[LinuxPovNumber];
    159 
    160                                 //Handle X Axis first (Even) (left right)
    161                                 if((LinuxPovNumber & 0x0001) == 0)
     131                                break;
     132                        }
     133
     134                        case EV_ABS:  //Absolute Axis
     135                        {
     136                                //A Stick (BrakeDefine is the highest possible Axis)
     137                                if( js[i].code <= ABS_BRAKE )
    162138                                {
    163                                         //Why do this? Because, we use a bit field, and when this axis is east,
    164                                         //it can't possibly be west too. So clear out the two X axes, then refil
    165                                         //it in with the new direction bit.
    166                                         //Clear the East/West Bit Flags first
    167                                         mState.mPOV[OIS_POVIndex].direction &= 0x11110011;
    168                                         if( js[i].value == -1 ) //Left
    169                                                 mState.mPOV[OIS_POVIndex].direction |= Pov::West;
    170                                         else if( js[i].value == 1 ) //Right
    171                                                 mState.mPOV[OIS_POVIndex].direction |= Pov::East;
     139                                        int axis = mAxisMap[js[i].code];
     140                                        assert( axis < 32 && "Too many axes (Max supported is 32). Report this to OIS forums!" );
     141
     142                                        axisMoved[axis] = true;
     143
     144                                        //check for rescaling:
     145                                        if( mRanges[axis].min == JoyStick::MIN_AXIS && mRanges[axis].max != JoyStick::MAX_AXIS )
     146                                        {       //Scale is perfect
     147                                                mState.mAxes[axis].abs = js[i].value;
     148                                        }
     149                                        else
     150                                        {       //Rescale
     151                                                float proportion = (float)(js[i].value-mRanges[axis].max)/(float)(mRanges[axis].min-mRanges[axis].max);
     152                                                mState.mAxes[axis].abs = (int)(32767.0f - (65535.0f * proportion));
     153                                        }
    172154                                }
    173                                 //Handle Y Axis (Odd) (up down)
    174                                 else
     155                                else if( js[i].code <= ABS_HAT3Y ) //A POV - Max four POVs allowed
    175156                                {
    176                                         //Clear the North/South Bit Flags first
    177                                         mState.mPOV[OIS_POVIndex].direction &= 0x11111100;
    178                                         if( js[i].value == -1 ) //Up
    179                                                 mState.mPOV[OIS_POVIndex].direction |= Pov::North;
    180                                         else if( js[i].value == 1 ) //Down
    181                                                 mState.mPOV[OIS_POVIndex].direction |= Pov::South;
     157                                        //Normalise the POV to between 0-7
     158                                        //Even is X Axis, Odd is Y Axis
     159                                        unsigned char LinuxPovNumber = js[i].code - 16;
     160                                        short OIS_POVIndex = POV_MASK[LinuxPovNumber];
     161
     162                                        //Handle X Axis first (Even) (left right)
     163                                        if((LinuxPovNumber & 0x0001) == 0)
     164                                        {
     165                                                //Why do this? Because, we use a bit field, and when this axis is east,
     166                                                //it can't possibly be west too. So clear out the two X axes, then refil
     167                                                //it in with the new direction bit.
     168                                                //Clear the East/West Bit Flags first
     169                                                mState.mPOV[OIS_POVIndex].direction &= 0x11110011;
     170                                                if( js[i].value == -1 ) //Left
     171                                                        mState.mPOV[OIS_POVIndex].direction |= Pov::West;
     172                                                else if( js[i].value == 1 ) //Right
     173                                                        mState.mPOV[OIS_POVIndex].direction |= Pov::East;
     174                                        }
     175                                        //Handle Y Axis (Odd) (up down)
     176                                        else
     177                                        {
     178                                                //Clear the North/South Bit Flags first
     179                                                mState.mPOV[OIS_POVIndex].direction &= 0x11111100;
     180                                                if( js[i].value == -1 ) //Up
     181                                                        mState.mPOV[OIS_POVIndex].direction |= Pov::North;
     182                                                else if( js[i].value == 1 ) //Down
     183                                                        mState.mPOV[OIS_POVIndex].direction |= Pov::South;
     184                                        }
     185
     186                                        if( mBuffered && mListener )
     187                                                if( mListener->povMoved( JoyStickEvent(this,mState), OIS_POVIndex) == false )
     188                                                        return;
    182189                                }
    183 
    184                                 if( mBuffered && mListener )
    185                                         if( mListener->povMoved( JoyStickEvent(this,mState), OIS_POVIndex) == false )
    186                                                 return;
    187                         }
    188                         break;
    189                 }
    190 
    191                
    192                 case EV_REL: //Relative Axes (Do any joystick actually have a relative axis?)
    193 #ifdef OIS_LINUX_JOY_DEBUG
    194                     cout << "\nWarning: Relatives axes not supported yet" << endl;
    195 #endif
    196                         break;
    197                 default: break;
     190                                break;
     191                        }
     192
     193                       
     194                        case EV_REL: //Relative Axes (Do any joystick actually have a relative axis?)
     195        #ifdef OIS_LINUX_JOY_DEBUG
     196                                cout << "\nWarning: Relatives axes not supported yet" << endl;
     197        #endif
     198                                break;
     199                        default: break;
     200                        }
    198201                }
    199202        }
  • code/branches/ois_update/src/external/ois/linux/LinuxKeyboard.cpp

    r5781 r7506  
    3333#include <iostream>
    3434//-------------------------------------------------------------------//
    35 LinuxKeyboard::LinuxKeyboard(InputManager* creator, bool buffered, bool grab, bool useXRepeat)
     35LinuxKeyboard::LinuxKeyboard(InputManager* creator, bool buffered, bool grab)
    3636        : Keyboard(creator->inputSystemName(), buffered, 0, creator)
    3737{
     
    4343        grabKeyboard = grab;
    4444        keyFocusLost = false;
    45 
    46         xAutoRepeat = useXRepeat;
    47         oldXAutoRepeat = false;
    4845
    4946        //X Key Map to KeyCode
     
    213210
    214211        keyFocusLost = false;
    215 
    216         if( xAutoRepeat == false )
    217         {
    218                 //We do not want to blindly turn on autorepeat later when quiting if
    219                 //it was not on to begin with.. So, let us check and see first
    220                 XKeyboardState old;
    221                 XGetKeyboardControl( display, &old );
    222                 oldXAutoRepeat = false;
    223 
    224                 if( old.global_auto_repeat == AutoRepeatModeOn )
    225                         oldXAutoRepeat = true;
    226 
    227                 XAutoRepeatOff( display );
    228         }
    229212}
    230213
     
    234217        if( display )
    235218        {
    236                 if( oldXAutoRepeat )
    237                         XAutoRepeatOn(display);
    238 
    239219                if( grabKeyboard )
    240220                        XUngrabKeyboard(display, CurrentTime);
     
    303283
    304284        while( XPending(display) > 0 )
    305         {               XNextEvent(display, &event);            if( KeyPress == event.type )
     285        {
     286                XNextEvent(display, &event);            if(KeyPress == event.type)
    306287                {
    307288                        unsigned int character = 0;
    308289
    309                         if( mTextMode != Off )
     290                        if(mTextMode != Off)
    310291                        {
    311292                                unsigned char buffer[6] = {0,0,0,0,0,0};
     
    332313                        if( event.xkey.state & Mod1Mask && key == XK_Tab )
    333314                                linMan->_setGrabState(false);
    334                 }               else if( KeyRelease == event.type )
     315                }
     316                else if(KeyRelease == event.type)
    335317                {
    336                         //Mask out the modifier states X sets.. or we will get improper values
    337                         event.xkey.state &= ~ShiftMask;
    338                         event.xkey.state &= ~LockMask;
    339 
    340                         //Else, it is a valid key release
    341                         XLookupString(&event.xkey,NULL,0,&key,NULL);
    342                         _injectKeyUp(key);              }
     318                        if(!_isKeyRepeat(event))
     319                        {
     320                                //Mask out the modifier states X sets.. or we will get improper values
     321                                event.xkey.state &= ~ShiftMask;
     322                                event.xkey.state &= ~LockMask;
     323
     324                                XLookupString(&event.xkey,NULL,0,&key,NULL);
     325                                _injectKeyUp(key);
     326                        }
     327                }
    343328        }
    344329
  • code/branches/ois_update/src/external/ois/linux/LinuxKeyboard.h

    r5781 r7506  
    3434        {
    3535        public:
    36                 LinuxKeyboard(InputManager* creator, bool buffered, bool grab, bool useXRepeat );
     36                LinuxKeyboard(InputManager* creator, bool buffered, bool grab);
    3737                virtual ~LinuxKeyboard();
    3838
     
    5959
    6060        protected:
     61                inline bool _isKeyRepeat(XEvent &event)
     62                {
     63                        //When a key is repeated, there will be two events: released, followed by another immediate pressed. So check to see if another pressed is present     
     64                        if(!XPending(display))
     65                                return false;
     66
     67                        XEvent e;
     68                        XPeekEvent(display, &e);
     69                        if(e.type == KeyPress && e.xkey.keycode == event.xkey.keycode && (e.xkey.time - event.xkey.time) < 2)
     70                        {
     71                                XNextEvent(display, &e);
     72                                return true;
     73                        }
     74
     75                        return false;
     76                }
     77
    6178                bool _injectKeyDown( KeySym key, int text );
    6279                bool _injectKeyUp( KeySym key );
     
    7592                bool keyFocusLost;
    7693
    77                 bool xAutoRepeat;
    78                 bool oldXAutoRepeat;
    79 
    8094                std::string mGetString;
    8195        };
  • code/branches/ois_update/src/external/ois/linux/LinuxMouse.cpp

    r5781 r7506  
    173173
    174174                        //Compute this frames Relative X & Y motion
    175                         mState.X.rel = event.xmotion.x - oldXMouseX;
    176                         mState.Y.rel = event.xmotion.y - oldXMouseY;
     175                        int dx = event.xmotion.x - oldXMouseX;
     176                        int dy = event.xmotion.y - oldXMouseY;
    177177               
    178178                        //Store old values for next time to compute relative motion
     
    180180                        oldXMouseY = event.xmotion.y;
    181181
    182                         mState.X.abs += mState.X.rel;
    183                         mState.Y.abs += mState.Y.rel;
     182                        mState.X.abs += dx;
     183                        mState.Y.abs += dy;
     184                        mState.X.rel += dx;
     185                        mState.Y.rel += dy;
    184186
    185187                        //Check to see if we are grabbing the mouse to the window (requires clipping and warping)
  • code/branches/ois_update/src/external/ois/linux/LinuxPrereqs.h

    r5781 r7506  
    3232
    3333//! Max number of elements to collect from buffered input
    34 #define JOY_BUFFERSIZE 10
     34#define JOY_BUFFERSIZE 64
    3535
    3636namespace OIS
  • code/branches/ois_update/src/external/ois/mac/MacHIDManager.cpp

    r5781 r7506  
    2020 
    2121 3. This notice may not be removed or altered from any source distribution.
    22 */
     22 */
    2323#include "mac/MacHIDManager.h"
     24#include "mac/MacJoyStick.h"
    2425#include "OISException.h"
    2526#include "OISObject.h"
     
    4243{
    4344        CFTypeRef temp = CFDictionaryGetValue(dict, OIS_CFString(keyName));
    44 
     45       
    4546        if(temp && CFGetTypeID(temp) == CFArrayGetTypeID())
    4647                return (CFArrayRef)temp;
     
    5354{
    5455        CFTypeRef temp = CFDictionaryGetValue(dict, OIS_CFString(keyName));
    55 
     56       
    5657        if(temp && CFGetTypeID(temp) == CFStringGetTypeID())
    5758                return (CFStringRef)temp;
     
    6465{
    6566        CFTypeRef temp = CFDictionaryGetValue(dict, OIS_CFString(keyName));
    66 
     67       
    6768        if(temp && CFGetTypeID(temp) == CFNumberGetTypeID())
    6869                return (CFNumberRef)temp;
     
    8384{
    8485        CFTypeRef temp = CFArrayGetValueAtIndex(array, idx);
    85 
     86       
    8687        if(temp && CFGetTypeID(temp) == CFDictionaryGetTypeID())
    8788                return (CFDictionaryRef)temp;
     
    9394int getInt32(CFNumberRef ref)
    9495{
    95    int r = 0;
    96    if (r)
    97       CFNumberGetValue(ref, kCFNumberIntType, &r);
    98    return r;
     96        int r = 0;
     97        if (r)
     98                CFNumberGetValue(ref, kCFNumberIntType, &r);
     99        return r;
    99100}
    100101
     
    111112//------------------------------------------------------------------------------------------------------//
    112113void MacHIDManager::initialize()
     114{
     115        //Make the search more specific by adding usage flags
     116        int usage = kHIDUsage_GD_Joystick;
     117        int page = kHIDPage_GenericDesktop;
     118       
     119        io_iterator_t iterator = lookUpDevices(usage, page);
     120       
     121        if(iterator)
     122                iterateAndOpenDevices(iterator);
     123       
     124        //Doesn't support multiple usage flags, iterate twice
     125        usage = kHIDUsage_GD_GamePad;
     126        iterator = lookUpDevices(usage, page);
     127       
     128        if(iterator)
     129                iterateAndOpenDevices(iterator);
     130}
     131
     132//------------------------------------------------------------------------------------------------------//
     133io_iterator_t MacHIDManager::lookUpDevices(int usage, int page)
    113134{
    114135        CFMutableDictionaryRef deviceLookupMap = IOServiceMatching(kIOHIDDeviceKey);
    115136        if(!deviceLookupMap)
    116137                OIS_EXCEPT(E_General, "Could not setup HID device search parameters");
    117 
    118         //Make the search more specific by adding usage flags
    119         int usage = kHIDUsage_GD_GamePad | kHIDUsage_GD_Joystick,
    120             page  = kHIDPage_GenericDesktop;
    121 
    122         CFNumberRef usageRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &usage),
    123                                 pageRef  = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &page);
    124 
     138       
     139        CFNumberRef usageRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &usage);
     140        CFNumberRef pageRef  = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &page);
     141       
    125142        CFDictionarySetValue(deviceLookupMap, CFSTR(kIOHIDPrimaryUsageKey), usageRef);
    126143        CFDictionarySetValue(deviceLookupMap, CFSTR(kIOHIDPrimaryUsagePageKey), pageRef);
    127 
     144       
    128145        //IOServiceGetMatchingServices consumes the map so we do not have to release it ourself
    129146        io_iterator_t iterator = 0;
    130147        IOReturn result = IOServiceGetMatchingServices(kIOMasterPortDefault, deviceLookupMap, &iterator);
    131         if (result == kIOReturnSuccess && iterator)
    132         {
    133                 io_object_t hidDevice = 0;
    134                 while ((hidDevice = IOIteratorNext(iterator)) !=0)
     148       
     149        CFRelease(usageRef);
     150        CFRelease(pageRef);
     151       
     152        if(result == kIOReturnSuccess)
     153        {
     154                return iterator;
     155        }
     156        //TODO: Throw exception instead?
     157        else
     158        {
     159                return 0;
     160        }
     161}
     162
     163//------------------------------------------------------------------------------------------------------//
     164void MacHIDManager::iterateAndOpenDevices(io_iterator_t iterator)
     165{
     166        io_object_t hidDevice = 0;
     167        while ((hidDevice = IOIteratorNext(iterator)) !=0)
     168        {
     169                //Get the current registry items property map
     170                CFMutableDictionaryRef propertyMap = 0;
     171                if (IORegistryEntryCreateCFProperties(hidDevice, &propertyMap, kCFAllocatorDefault, kNilOptions) == KERN_SUCCESS && propertyMap)
    135172                {
    136                         //Get the current registry items property map
    137                         CFMutableDictionaryRef propertyMap = 0;
    138                         if (IORegistryEntryCreateCFProperties(hidDevice, &propertyMap, kCFAllocatorDefault, kNilOptions) == KERN_SUCCESS && propertyMap)
     173                        //Go through device to find all needed info
     174                        HidInfo* hid = enumerateDeviceProperties(propertyMap);
     175                       
     176                        if(hid)
    139177                        {
    140                                 //Go through device to find all needed info
    141                                 HidInfo* hid = enumerateDeviceProperties(propertyMap);
    142                                 if(hid)
    143                                         mDeviceList.push_back(hid);
    144                                        
    145178                                //todo - we need to hold an open interface so we do not have to enumerate again later
    146179                                //should be able to watch for device removals also
    147 
    148                                 /// Testing opening / closing interface
    149                                 //IOCFPlugInInterface **pluginInterface = NULL;
    150                                 //SInt32 score = 0;
    151                                 //if (IOCreatePlugInInterfaceForService(hidDevice, kIOHIDDeviceUserClientTypeID, kIOCFPlugInInterfaceID, &pluginInterface, &score) == kIOReturnSuccess)
    152                                 //{
    153                                 //      IOHIDDeviceInterface **interface;
    154                                 //      HRESULT pluginResult = (*pluginInterface)->QueryInterface(pluginInterface, CFUUIDGetUUIDBytes(kIOHIDDeviceInterfaceID), (void **)&(interface));
    155                                 //      if(pluginResult == S_OK)
    156                                 //              cout << "Successfully created plugin interface for device\n";
    157                                 //      else
    158                                 //              cout << "Not able to create plugin interface\n";
    159 
    160                                 //      IODestroyPlugInInterface(pluginInterface);
    161 
    162                                 //      if ((*interface)->open(interface, 0) == KERN_SUCCESS)
    163                                 //              cout << "Opened interface.\n";
    164                                 //      else
    165                                 //              cout << "Failed to open\n";
    166 
    167                                 //      (*interface)->close(interface);
    168                                 //}
    169                                 //
     180                               
     181                                // Testing opening / closing interface
     182                                IOCFPlugInInterface **pluginInterface = NULL;
     183                                SInt32 score = 0;
     184                                if (IOCreatePlugInInterfaceForService(hidDevice, kIOHIDDeviceUserClientTypeID, kIOCFPlugInInterfaceID, &pluginInterface, &score) == kIOReturnSuccess)
     185                                {
     186                                        IOHIDDeviceInterface **interface;
     187                                       
     188                                        HRESULT pluginResult = (*pluginInterface)->QueryInterface(pluginInterface, CFUUIDGetUUIDBytes(kIOHIDDeviceInterfaceID), (void **)&(interface));
     189                                       
     190                                        if(pluginResult != S_OK)
     191                                                OIS_EXCEPT(E_General, "Not able to create plugin interface");
     192                                       
     193                                        IODestroyPlugInInterface(pluginInterface);
     194                                       
     195                                        hid->interface = interface;
     196                                       
     197                                        //Check for duplicates - some devices have multiple usage
     198                                        if(std::find(mDeviceList.begin(), mDeviceList.end(), hid) == mDeviceList.end())
     199                                                mDeviceList.push_back(hid);
     200                                }
    170201                        }
    171202                }
    172 
    173                 IOObjectRelease(iterator);
    174         }
    175 
    176         CFRelease(usageRef);
    177         CFRelease(pageRef);
     203        }
     204       
     205        IOObjectRelease(iterator);
    178206}
    179207
     
    188216        if (str)
    189217                info->vendor = CFStringGetCStringPtr(str, CFStringGetSystemEncoding());
    190 
     218       
    191219        str = getDictionaryItemAsRef<CFStringRef>(propertyMap, kIOHIDProductKey);
    192220        if (str)
    193221                info->productKey = CFStringGetCStringPtr(str, CFStringGetSystemEncoding());
    194                
     222       
    195223        info->combinedKey = info->vendor + " " + info->productKey;
    196 
     224       
    197225        //Go through all items in this device (i.e. buttons, hats, sticks, axes, etc)
    198226        CFArrayRef array = getDictionaryItemAsRef<CFArrayRef>(propertyMap, kIOHIDElementKey);
     
    200228                for (int i = 0; i < CFArrayGetCount(array); i++)
    201229                        parseDeviceProperties(getArrayItemAsRef<CFDictionaryRef>(array, i));
    202 
     230       
    203231        return info;
    204232}
     
    209237        if(!properties)
    210238                return;
    211 
     239       
    212240        CFArrayRef array = getDictionaryItemAsRef<CFArrayRef>(properties, kIOHIDElementKey);
    213241        if (array)
     
    227255                                        switch(getInt32(getDictionaryItemAsRef<CFNumberRef>(element, kIOHIDElementUsagePageKey)))
    228256                                        {
    229                                         case kHIDPage_GenericDesktop:
    230                                                 switch(getInt32(getDictionaryItemAsRef<CFNumberRef>(element, kIOHIDElementUsageKey)))
     257                                                case kHIDPage_GenericDesktop:
     258                                                        switch(getInt32(getDictionaryItemAsRef<CFNumberRef>(element, kIOHIDElementUsageKey)))
    231259                                                {
    232                                                 case kHIDUsage_GD_Pointer:
    233                                                         cout << "\tkHIDUsage_GD_Pointer\n";
    234                                                         parseDevicePropertiesGroup(element);
     260                                                        case kHIDUsage_GD_Pointer:
     261                                                                cout << "\tkHIDUsage_GD_Pointer\n";
     262                                                                parseDevicePropertiesGroup(element);
     263                                                                break;
     264                                                        case kHIDUsage_GD_X:
     265                                                        case kHIDUsage_GD_Y:
     266                                                        case kHIDUsage_GD_Z:
     267                                                        case kHIDUsage_GD_Rx:
     268                                                        case kHIDUsage_GD_Ry:
     269                                                        case kHIDUsage_GD_Rz:
     270                                                                cout << "\tAxis\n";
     271                                                                break;
     272                                                        case kHIDUsage_GD_Slider:
     273                                                        case kHIDUsage_GD_Dial:
     274                                                        case kHIDUsage_GD_Wheel:
     275                                                                cout << "\tUnsupported kHIDUsage_GD_Wheel\n";
     276                                                                break;
     277                                                        case kHIDUsage_GD_Hatswitch:
     278                                                                cout << "\tUnsupported - kHIDUsage_GD_Hatswitch\n";
     279                                                                break;
     280                                                }
    235281                                                        break;
    236                                                 case kHIDUsage_GD_X:
    237                                                 case kHIDUsage_GD_Y:
    238                                                 case kHIDUsage_GD_Z:
    239                                                 case kHIDUsage_GD_Rx:
    240                                                 case kHIDUsage_GD_Ry:
    241                                                 case kHIDUsage_GD_Rz:
    242                                                         cout << "\tAxis\n";
     282                                                case kHIDPage_Button:
     283                                                        cout << "\tkHIDPage_Button\n";
    243284                                                        break;
    244                                                 case kHIDUsage_GD_Slider:
    245                                                 case kHIDUsage_GD_Dial:
    246                                                 case kHIDUsage_GD_Wheel:
    247                                                         cout << "\tUnsupported kHIDUsage_GD_Wheel\n";
    248                                                         break;
    249                                                 case kHIDUsage_GD_Hatswitch:
    250                                                         cout << "\tUnsupported - kHIDUsage_GD_Hatswitch\n";
    251                                                         break;
    252                                                 }
    253                                                 break;
    254                                         case kHIDPage_Button:
    255                                                 cout << "\tkHIDPage_Button\n";
    256                                                 break;
    257285                                        }
    258286                                }
     
    267295        if(!properties)
    268296                return;
    269 
     297       
    270298        CFArrayRef array = getDictionaryItemAsRef<CFArrayRef>(properties, kIOHIDElementKey);
    271299        if(array)
     
    278306                                switch(getInt32(getDictionaryItemAsRef<CFNumberRef>(element, kIOHIDElementUsagePageKey)))
    279307                                {
    280                                 case kHIDPage_GenericDesktop:
    281                                         switch(getInt32(getDictionaryItemAsRef<CFNumberRef>(element, kIOHIDElementUsageKey)))
     308                                        case kHIDPage_GenericDesktop:
     309                                                switch(getInt32(getDictionaryItemAsRef<CFNumberRef>(element, kIOHIDElementUsageKey)))
    282310                                        {
    283                                         case kHIDUsage_GD_X:
    284                                         case kHIDUsage_GD_Y:
    285                                         case kHIDUsage_GD_Z:
    286                                         case kHIDUsage_GD_Rx:
    287                                         case kHIDUsage_GD_Ry:
    288                                         case kHIDUsage_GD_Rz:
    289                                                 cout << "\t\tAxis\n";
     311                                                case kHIDUsage_GD_X:
     312                                                case kHIDUsage_GD_Y:
     313                                                case kHIDUsage_GD_Z:
     314                                                case kHIDUsage_GD_Rx:
     315                                                case kHIDUsage_GD_Ry:
     316                                                case kHIDUsage_GD_Rz:
     317                                                        cout << "\t\tAxis\n";
     318                                                        break;
     319                                                case kHIDUsage_GD_Slider:
     320                                                case kHIDUsage_GD_Dial:
     321                                                case kHIDUsage_GD_Wheel:
     322                                                        cout << "\tUnsupported - kHIDUsage_GD_Wheel\n";
     323                                                        break;
     324                                                case kHIDUsage_GD_Hatswitch:
     325                                                        cout << "\tUnsupported - kHIDUsage_GD_Hatswitch\n";
     326                                                        break;
     327                                        }
    290328                                                break;
    291                                         case kHIDUsage_GD_Slider:
    292                                         case kHIDUsage_GD_Dial:
    293                                         case kHIDUsage_GD_Wheel:
    294                                                 cout << "\tUnsupported - kHIDUsage_GD_Wheel\n";
     329                                        case kHIDPage_Button:
    295330                                                break;
    296                                         case kHIDUsage_GD_Hatswitch:
    297                                                 cout << "\tUnsupported - kHIDUsage_GD_Hatswitch\n";
    298                                                 break;
    299                                         }
    300                                         break;
    301                                 case kHIDPage_Button:
    302                                         break;
    303331                                }
    304332                        }
     
    317345                        ret.insert(std::make_pair((*it)->type, (*it)->combinedKey));
    318346        }
    319 
     347       
    320348        return ret;
    321349}
     
    326354        int ret = 0;
    327355        HidInfoList::iterator it = mDeviceList.begin(), end = mDeviceList.end();
    328 
     356       
    329357        for(; it != end; ++it)
    330358        {
     
    341369        int ret = 0;
    342370        HidInfoList::iterator it = mDeviceList.begin(), end = mDeviceList.end();
    343 
     371       
    344372        for(; it != end; ++it)
    345373        {
     
    347375                        ret++;
    348376        }
    349 
     377       
    350378        return ret;
    351379}
     
    355383{
    356384        HidInfoList::iterator it = mDeviceList.begin(), end = mDeviceList.end();
    357 
     385       
    358386        for(; it != end; ++it)
    359387        {
     
    367395//--------------------------------------------------------------------------------//
    368396Object* MacHIDManager::createObject(InputManager* creator, Type iType, bool bufferMode,
    369                                                                           const std::string & vendor)
     397                                                                        const std::string & vendor)
    370398{
    371399        Object *obj = 0;
    372 
     400       
    373401        HidInfoList::iterator it = mDeviceList.begin(), end = mDeviceList.end();
    374402        for(; it != end; ++it)
     
    376404                if((*it)->inUse == false && (*it)->type == iType && (vendor == "" || (*it)->combinedKey == vendor))
    377405                {
    378                         //create device
     406                        switch(iType)
     407                        {
     408                                case OISJoyStick:
     409                                        int totalDevs = totalDevices(iType);
     410                                        int freeDevs = freeDevices(iType);
     411                                        int devID = totalDevs - freeDevs;
     412                                       
     413                                        obj = new MacJoyStick((*it)->combinedKey, bufferMode, *it, creator, devID);
     414                                        (*it)->inUse = true;
     415                                        return obj;
     416                                case OISTablet:
     417                                        //Create MacTablet
     418                                        break;
     419                                default:
     420                                        break;
     421                        }
    379422                }
    380423        }
    381 
    382         if( obj == 0 )
    383                 OIS_EXCEPT(E_InputDeviceNonExistant, "No devices match requested type.");
    384 
     424       
    385425        return obj;
    386426}
  • code/branches/ois_update/src/external/ois/mac/MacHIDManager.h

    r5781 r7506  
    7070
    7171                void initialize();
     72               
     73                void iterateAndOpenDevices(io_iterator_t iterator);
     74                io_iterator_t lookUpDevices(int usage, int page);
    7275
    7376                //FactoryCreator Overrides
  • code/branches/ois_update/src/external/ois/mac/MacInputManager.cpp

    r5781 r7506  
    188188        }
    189189        default:
     190        {
     191                obj = mHIDManager->createObject(creator, iType, bufferMode, vendor);
    190192                break;
     193        }
    191194        }
    192195
  • code/branches/ois_update/src/external/ois/win32/Win32ForceFeedback.cpp

    r5929 r7506  
    2121    3. This notice may not be removed or altered from any source distribution.
    2222*/
    23 #include "Win32/Win32ForceFeedback.h"
     23#include "win32/Win32ForceFeedback.h"
    2424#include "OISException.h"
    25 #include <Math.h>
     25#include <math.h>
    2626
    2727// 0 = No trace; 1 = Important traces; 2 = Debug traces
  • code/branches/ois_update/src/external/ois/win32/Win32ForceFeedback.h

    r5781 r7506  
    2626#include "OISPrereqs.h"
    2727#include "OISForceFeedback.h"
    28 #include "Win32/Win32Prereqs.h"
     28#include "win32/Win32Prereqs.h"
    2929
    3030namespace OIS
  • code/branches/ois_update/src/external/ois/win32/Win32InputManager.cpp

    r5781 r7506  
    2121    3. This notice may not be removed or altered from any source distribution.
    2222*/
    23 #include "Win32/Win32InputManager.h"
    24 #include "Win32/Win32Keyboard.h"
    25 #include "Win32/Win32Mouse.h"
    26 #include "Win32/Win32JoyStick.h"
     23#include "win32/Win32InputManager.h"
     24#include "win32/Win32KeyBoard.h"
     25#include "win32/Win32Mouse.h"
     26#include "win32/Win32JoyStick.h"
    2727#include "OISException.h"
    2828
     
    7575        hInst = GetModuleHandle(0);
    7676
    77         //Create the input system
     77        //Create the device
    7878        hr = DirectInput8Create( hInst, DIRECTINPUT_VERSION, IID_IDirectInput8, (VOID**)&mDirectInput, NULL );
    7979    if (FAILED(hr))     
     
    118118{
    119119        //Enumerate all attached devices
    120         mDirectInput->EnumDevices(NULL , _DIEnumDevCallback, this, DIEDFL_ATTACHEDONLY);
     120        mDirectInput->EnumDevices(NULL, _DIEnumDevCallback, this, DIEDFL_ATTACHEDONLY);
     121
     122#ifdef OIS_WIN32_XINPUT_SUPPORT
     123        //let's check how many possible XInput devices we may have (max 4)...
     124        for(int i = 0; i < 3; ++i)
     125        {
     126                XINPUT_STATE state;
     127                if(XInputGetState(i, &state) != ERROR_DEVICE_NOT_CONNECTED)
     128                {       //Once we found 1, just check our whole list against devices
     129                        Win32JoyStick::CheckXInputDevices(unusedJoyStickList);
     130                        break;
     131                }
     132        }
     133#endif
    121134}
    122135
     
    134147        {
    135148                JoyStickInfo jsInfo;
     149                jsInfo.isXInput = false;
     150                jsInfo.productGuid = lpddi->guidProduct;
    136151                jsInfo.deviceID = lpddi->guidInstance;
    137152                jsInfo.vendor = lpddi->tszInstanceName;
  • code/branches/ois_update/src/external/ois/win32/Win32InputManager.h

    r5781 r7506  
    2626#include "OISInputManager.h"
    2727#include "OISFactoryCreator.h"
    28 #include "Win32/Win32Prereqs.h"
     28#include "win32/Win32Prereqs.h"
    2929
    3030namespace OIS
  • code/branches/ois_update/src/external/ois/win32/Win32JoyStick.cpp

    r5781 r7506  
    2121    3. This notice may not be removed or altered from any source distribution.
    2222*/
    23 #include "Win32/Win32JoyStick.h"
    24 #include "Win32/Win32InputManager.h"
    25 #include "Win32/Win32ForceFeedback.h"
     23#include "win32/Win32JoyStick.h"
     24#include "win32/Win32InputManager.h"
     25#include "win32/Win32ForceFeedback.h"
    2626#include "OISEvents.h"
    2727#include "OISException.h"
    2828
    2929#include <cassert>
     30#include <wbemidl.h>
     31#include <oleauto.h>
     32//#include <wmsstd.h>
     33#ifndef SAFE_RELEASE
     34#define SAFE_RELEASE(x) \
     35   if(x != NULL)        \
     36   {                    \
     37      x->Release();     \
     38      x = NULL;         \
     39   }
     40#endif
     41
     42#ifdef OIS_WIN32_XINPUT_SUPPORT
     43#       pragma comment(lib, "xinput.lib")
     44#endif
    3045
    3146//DX Only defines macros for the JOYSTICK not JOYSTICK2, so fix it
     
    4055#define DIJOFS_SLIDER3(n) (FIELD_OFFSET(DIJOYSTATE2, rglFSlider)+(n) * sizeof(LONG))
    4156
     57#define XINPUT_TRANSLATED_BUTTON_COUNT 12
     58#define XINPUT_TRANSLATED_AXIS_COUNT 6
     59
    4260using namespace OIS;
    4361
    4462//--------------------------------------------------------------------------------------------------//
    45 Win32JoyStick::Win32JoyStick( InputManager* creator, IDirectInput8* pDI,
    46         bool buffered, DWORD coopSettings, const JoyStickInfo &info )
    47         : JoyStick(info.vendor, buffered, info.devId, creator)
    48 {
    49         mDirectInput = pDI;
    50         coopSetting = coopSettings;
    51         mJoyStick = 0;
    52 
    53         deviceGuid = info.deviceID;
    54 
    55         ff_device = 0;
     63Win32JoyStick::Win32JoyStick( InputManager* creator, IDirectInput8* pDI, bool buffered, DWORD coopSettings, const JoyStickInfo &info ) :
     64        JoyStick(info.vendor, buffered, info.devId, creator),
     65        mDirectInput(pDI),
     66        coopSetting(coopSettings),
     67        mJoyStick(0),
     68        mJoyInfo(info),
     69        mFfDevice(0)
     70{
    5671}
    5772
     
    5974Win32JoyStick::~Win32JoyStick()
    6075{
    61         delete ff_device;
     76        delete mFfDevice;
    6277
    6378        if(mJoyStick)
     
    6984
    7085        //Return joystick to pool
    71         JoyStickInfo js;
    72         js.deviceID = deviceGuid;
    73         js.devId = mDevID;
    74         js.vendor = mVendor;
    75         static_cast<Win32InputManager*>(mCreator)->_returnJoyStick(js);
     86        static_cast<Win32InputManager*>(mCreator)->_returnJoyStick(mJoyInfo);
    7687}
    7788
     
    7990void Win32JoyStick::_initialize()
    8091{
    81         //Clear old state
    82         mState.mAxes.clear();
    83 
    84         if (ff_device)
    85         {
    86                 delete ff_device;
    87                 ff_device = 0;
    88         }
    89 
    90         // Create direct input joystick device.
    91         if(FAILED(mDirectInput->CreateDevice(deviceGuid, &mJoyStick, NULL)))
    92                 OIS_EXCEPT( E_General, "Win32JoyStick::_initialize() >> Could not initialize joy device!");
    93 
    94         // Set DIJoystick2 data format.
    95         if(FAILED(mJoyStick->SetDataFormat(&c_dfDIJoystick2)))
    96                 OIS_EXCEPT( E_General, "Win32JoyStick::_initialize() >> data format error!");
    97 
    98         // Set cooperative level as specified when creating input manager.
    99         HWND hwin = ((Win32InputManager*)mCreator)->getWindowHandle();
    100         if(FAILED(mJoyStick->SetCooperativeLevel( hwin, coopSetting)))
    101                 OIS_EXCEPT( E_General, "Win32JoyStick::_initialize() >> failed to set cooperation level!");
    102 
    103         // Set buffer size.
    104         DIPROPDWORD dipdw;
    105         dipdw.diph.dwSize       = sizeof(DIPROPDWORD);
    106         dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
    107         dipdw.diph.dwObj        = 0;
    108         dipdw.diph.dwHow        = DIPH_DEVICE;
    109         dipdw.dwData            = JOYSTICK_DX_BUFFERSIZE;
    110 
    111         if( FAILED(mJoyStick->SetProperty(DIPROP_BUFFERSIZE, &dipdw.diph)) )
    112                 OIS_EXCEPT( E_General, "Win32JoyStick::_initialize >> Failed to set buffer size property" );
    113 
    114         // Enumerate all axes/buttons/sliders/force feedback/etc before aquiring
    115         _enumerate();
    116 
    117         mState.clear();
    118 
    119         capture();
     92    if (mJoyInfo.isXInput)
     93    {
     94        _enumerate();
     95    }
     96    else
     97    {
     98            //Clear old state
     99            mState.mAxes.clear();
     100
     101            delete mFfDevice;
     102            mFfDevice = 0;
     103
     104            DIPROPDWORD dipdw;
     105
     106            dipdw.diph.dwSize       = sizeof(DIPROPDWORD);
     107            dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
     108            dipdw.diph.dwObj        = 0;
     109            dipdw.diph.dwHow        = DIPH_DEVICE;
     110            dipdw.dwData            = JOYSTICK_DX_BUFFERSIZE;
     111
     112            if(FAILED(mDirectInput->CreateDevice(mJoyInfo.deviceID, &mJoyStick, NULL)))
     113                    OIS_EXCEPT( E_General, "Win32JoyStick::_initialize() >> Could not initialize joy device!");
     114
     115            if(FAILED(mJoyStick->SetDataFormat(&c_dfDIJoystick2)))
     116                    OIS_EXCEPT( E_General, "Win32JoyStick::_initialize() >> data format error!");
     117
     118            HWND hwin = ((Win32InputManager*)mCreator)->getWindowHandle();
     119
     120            if(FAILED(mJoyStick->SetCooperativeLevel( hwin, coopSetting)))
     121                    OIS_EXCEPT( E_General, "Win32JoyStick::_initialize() >> failed to set cooperation level!");
     122
     123            if( FAILED(mJoyStick->SetProperty(DIPROP_BUFFERSIZE, &dipdw.diph)) )
     124                    OIS_EXCEPT( E_General, "Win32Mouse::Win32Mouse >> Failed to set buffer size property" );
     125
     126            //Enumerate all axes/buttons/sliders/etc before aquiring
     127            _enumerate();
     128
     129            mState.clear();
     130
     131            capture();
     132    }
    120133}
    121134
     
    123136void Win32JoyStick::_enumerate()
    124137{
    125         // Get joystick capabilities.
    126         mDIJoyCaps.dwSize = sizeof(DIDEVCAPS);
    127         if( FAILED(mJoyStick->GetCapabilities(&mDIJoyCaps)) )
    128                 OIS_EXCEPT( E_General, "Win32JoyStick::_enumerate >> Failed to get capabilities" );
    129 
    130         // => Number of POVs
    131         mPOVs = (short)mDIJoyCaps.dwPOVs;
    132 
    133         // => Number of buttons and axes.
    134         mState.mButtons.resize(mDIJoyCaps.dwButtons);
    135         mState.mAxes.resize(mDIJoyCaps.dwAxes);
    136 
    137         // Enumerate all Force Feedback effects (if any)
    138         mJoyStick->EnumEffects(DIEnumEffectsCallback, this, DIEFT_ALL);
    139 
    140         //Reset the axis mapping enumeration value
    141         _AxisNumber = 0;
    142 
    143         // Enumerate and set axis constraints (and check FF Axes)
    144         mJoyStick->EnumObjects(DIEnumDeviceObjectsCallback, this, DIDFT_AXIS);
     138    if (mJoyInfo.isXInput)
     139    {
     140        mPOVs = 1;
     141
     142        mState.mButtons.resize(XINPUT_TRANSLATED_BUTTON_COUNT);
     143            mState.mAxes.resize(XINPUT_TRANSLATED_AXIS_COUNT);
     144    }
     145    else
     146    {
     147                // Get joystick capabilities.
     148                mDIJoyCaps.dwSize = sizeof(DIDEVCAPS);
     149                if( FAILED(mJoyStick->GetCapabilities(&mDIJoyCaps)) )
     150                        OIS_EXCEPT( E_General, "Win32JoyStick::_enumerate >> Failed to get capabilities" );
     151
     152            mPOVs = (short)mDIJoyCaps.dwPOVs;
     153
     154            mState.mButtons.resize(mDIJoyCaps.dwButtons);
     155            mState.mAxes.resize(mDIJoyCaps.dwAxes);
     156
     157            //Reset the axis mapping enumeration value
     158            _AxisNumber = 0;
     159
     160            //Enumerate Force Feedback (if any)
     161            mJoyStick->EnumEffects(DIEnumEffectsCallback, this, DIEFT_ALL);
     162
     163            //Enumerate and set axis constraints (and check FF Axes)
     164            mJoyStick->EnumObjects(DIEnumDeviceObjectsCallback, this, DIDFT_AXIS);
     165    }
    145166}
    146167
     
    191212        if((lpddoi->dwFlags & DIDOI_FFACTUATOR) != 0 )
    192213        {
    193                 if( _this->ff_device )
     214                if( _this->mFfDevice )
    194215                {
    195                         _this->ff_device->_addFFAxis();
     216                        _this->mFfDevice->_addFFAxis();
    196217                }
    197218        }
     
    200221        //as DInput has no API to query the device for these capabilities
    201222        //(the only way to know is to try them ...)
    202         if( _this->ff_device )
    203         {
    204             _this->ff_device->_setGainSupport(true);
    205             _this->ff_device->_setAutoCenterSupport(true);
     223        if( _this->mFfDevice )
     224        {
     225            _this->mFfDevice->_setGainSupport(true);
     226            _this->mFfDevice->_setAutoCenterSupport(true);
    206227        }
    207228
     
    215236
    216237        //Create the FF instance only after we know there is at least one effect type
    217         if( _this->ff_device == 0 )
    218           _this->ff_device = new Win32ForceFeedback(_this->mJoyStick, &_this->mDIJoyCaps);
    219 
    220         _this->ff_device->_addEffectSupport( pdei );
     238        if( _this->mFfDevice == 0 )
     239                _this->mFfDevice = new Win32ForceFeedback(_this->mJoyStick, &_this->mDIJoyCaps);
     240
     241        _this->mFfDevice->_addEffectSupport(pdei);
    221242
    222243        return DIENUM_CONTINUE;
     
    226247void Win32JoyStick::capture()
    227248{
     249#ifdef OIS_WIN32_XINPUT_SUPPORT
     250        //handle xbox controller differently
     251    if (mJoyInfo.isXInput)
     252        {
     253                captureXInput();
     254                return;
     255        }
     256#endif
     257
     258        //handle directinput based devices
    228259        DIDEVICEOBJECTDATA diBuff[JOYSTICK_DX_BUFFERSIZE];
    229260        DWORD entries = JOYSTICK_DX_BUFFERSIZE;
     
    241272
    242273                // Poll the device to read the current state
    243             mJoyStick->Poll();
     274                mJoyStick->Poll();
    244275                hr = mJoyStick->GetDeviceData( sizeof(DIDEVICEOBJECTDATA), diBuff, &entries, 0 );
    245276                //Perhaps the user just tabbed away
     
    353384
    354385//--------------------------------------------------------------------------------------------------//
     386void Win32JoyStick::captureXInput()
     387{
     388#ifdef OIS_WIN32_XINPUT_SUPPORT
     389    XINPUT_STATE inputState;
     390        if (XInputGetState((DWORD)mJoyInfo.xInputDev, &inputState) != ERROR_SUCCESS)
     391        memset(&inputState, 0, sizeof(inputState));
     392
     393    //Sticks and triggers
     394        int value;
     395    bool axisMoved[XINPUT_TRANSLATED_AXIS_COUNT] = {false,false,false,false,false,false};
     396
     397        //LeftY
     398        value = -(int)inputState.Gamepad.sThumbLY;
     399        mState.mAxes[0].rel = value - mState.mAxes[0].abs;
     400        mState.mAxes[0].abs = value;
     401        if(mState.mAxes[0].rel != 0)
     402        axisMoved[0] = true;
     403
     404        //LeftX
     405    mState.mAxes[1].rel = inputState.Gamepad.sThumbLX - mState.mAxes[1].abs;
     406    mState.mAxes[1].abs = inputState.Gamepad.sThumbLX;
     407
     408        if(mState.mAxes[1].rel != 0)
     409        axisMoved[1] = true;
     410
     411        //RightY
     412        value = -(int)inputState.Gamepad.sThumbRY;           
     413    mState.mAxes[2].rel = value - mState.mAxes[2].abs;
     414    mState.mAxes[2].abs = value;
     415        if(mState.mAxes[2].rel != 0)
     416        axisMoved[2] = true;
     417
     418        //RightX
     419    mState.mAxes[3].rel = inputState.Gamepad.sThumbRX - mState.mAxes[3].abs;
     420    mState.mAxes[3].abs = inputState.Gamepad.sThumbRX;
     421        if(mState.mAxes[3].rel != 0)
     422                axisMoved[3] = true;
     423
     424        //Left trigger
     425    value = inputState.Gamepad.bLeftTrigger * 129;
     426        if(value > JoyStick::MAX_AXIS)
     427                value = JoyStick::MAX_AXIS;
     428
     429    mState.mAxes[4].rel = value - mState.mAxes[4].abs;
     430    mState.mAxes[4].abs = value;
     431        if(mState.mAxes[4].rel != 0)
     432                axisMoved[4] = true;
     433
     434        //Right trigger
     435    value = (int)inputState.Gamepad.bRightTrigger * 129;
     436        if(value > JoyStick::MAX_AXIS)
     437                value = JoyStick::MAX_AXIS;
     438
     439        mState.mAxes[5].rel = value - mState.mAxes[5].abs;
     440    mState.mAxes[5].abs = value;
     441        if(mState.mAxes[5].rel != 0)
     442                axisMoved[5] = true;
     443   
     444    //POV
     445    int previousPov = mState.mPOV[0].direction;       
     446    int& pov = mState.mPOV[0].direction;
     447    pov = Pov::Centered;       
     448    if (inputState.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_UP)
     449        pov |= Pov::North;
     450    else if (inputState.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_DOWN)
     451        pov |= Pov::South;
     452    if (inputState.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_LEFT)
     453        pov |= Pov::West;
     454    else if (inputState.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_RIGHT)
     455        pov |= Pov::East;
     456   
     457    //Buttons - The first 4 buttons don't need to be checked since they represent the dpad
     458    bool previousButtons[XINPUT_TRANSLATED_BUTTON_COUNT];
     459    std::copy(mState.mButtons.begin(), mState.mButtons.end(), previousButtons);
     460    for (size_t i = 0; i < XINPUT_TRANSLATED_BUTTON_COUNT; i++)
     461        mState.mButtons[i] = (inputState.Gamepad.wButtons & (1 << (i + 4))) != 0;
     462
     463    //Send events
     464    if (mBuffered && mListener)
     465    {
     466            JoyStickEvent joystickEvent(this, mState);
     467
     468            //Axes
     469            for (int i = 0; i < XINPUT_TRANSLATED_AXIS_COUNT; i++)
     470        {
     471                    if (axisMoved[i] && !mListener->axisMoved(joystickEvent, i))
     472                            return;
     473        }
     474
     475        //POV
     476        if (previousPov != pov && !mListener->povMoved(joystickEvent, 0))
     477            return;
     478
     479        //Buttons
     480        for (int i = 0; i < XINPUT_TRANSLATED_BUTTON_COUNT; i++)
     481        {
     482            if (!previousButtons[i] && mState.mButtons[i])
     483            {
     484                if (!mListener->buttonPressed(joystickEvent, i))
     485                    return;
     486            }
     487            else if (previousButtons[i] && !mState.mButtons[i])
     488            {
     489                if (!mListener->buttonReleased(joystickEvent, i))
     490                    return;
     491            }
     492        }
     493    }
     494#endif
     495}
     496
     497//--------------------------------------------------------------------------------------------------//
    355498bool Win32JoyStick::_doButtonClick( int button, DIDEVICEOBJECTDATA& di )
    356499{
     
    410553Interface* Win32JoyStick::queryInterface(Interface::IType type)
    411554{
    412         //Thought about using covariant return type here.. however,
    413         //some devices may allow LED light changing, or other interface stuff
    414 
    415         if( ff_device && type == Interface::ForceFeedback )
    416                 return ff_device;
     555        if( mFfDevice && type == Interface::ForceFeedback )
     556                return mFfDevice;
    417557        else
    418558                return 0;
    419559}
     560
     561//--------------------------------------------------------------------------------------------------//
     562void Win32JoyStick::CheckXInputDevices(JoyStickInfoList &joys)
     563{
     564    IWbemLocator*           pIWbemLocator  = NULL;
     565    IEnumWbemClassObject*   pEnumDevices   = NULL;
     566    IWbemClassObject*       pDevices[20]   = {0};
     567    IWbemServices*          pIWbemServices = NULL;
     568    BSTR                    bstrNamespace  = NULL;
     569    BSTR                    bstrDeviceID   = NULL;
     570    BSTR                    bstrClassName  = NULL;
     571    DWORD                   uReturned      = 0;
     572    bool                    bIsXinputDevice= false;
     573        DWORD                   iDevice        = 0;
     574        int                     xDevice        = 0;
     575    VARIANT                 var;
     576    HRESULT                 hr;
     577
     578        if(joys.size() == 0)
     579                return;
     580
     581    // CoInit if needed
     582    hr = CoInitialize(NULL);
     583    bool bCleanupCOM = SUCCEEDED(hr);
     584
     585    // Create WMI
     586    hr = CoCreateInstance(__uuidof(WbemLocator), NULL, CLSCTX_INPROC_SERVER, __uuidof(IWbemLocator), (LPVOID*)&pIWbemLocator);
     587    if( FAILED(hr) || pIWbemLocator == NULL )
     588        goto LCleanup;
     589
     590    bstrNamespace = SysAllocString( L"\\\\.\\root\\cimv2" );
     591        if( bstrNamespace == NULL )
     592                goto LCleanup;
     593
     594    bstrClassName = SysAllocString( L"Win32_PNPEntity" );
     595        if( bstrClassName == NULL )
     596                goto LCleanup;
     597
     598    bstrDeviceID  = SysAllocString( L"DeviceID" );
     599        if( bstrDeviceID == NULL )
     600                goto LCleanup;
     601   
     602    // Connect to WMI
     603    hr = pIWbemLocator->ConnectServer( bstrNamespace, NULL, NULL, 0L, 0L, NULL, NULL, &pIWbemServices );
     604    if( FAILED(hr) || pIWbemServices == NULL )
     605        goto LCleanup;
     606
     607    // Switch security level to IMPERSONATE.
     608    CoSetProxyBlanket(pIWbemServices, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL, RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE );                   
     609
     610    hr = pIWbemServices->CreateInstanceEnum( bstrClassName, 0, NULL, &pEnumDevices );
     611    if( FAILED(hr) || pEnumDevices == NULL )
     612        goto LCleanup;
     613
     614    // Loop over all devices
     615    for( ;; )
     616    {
     617        // Get 20 at a time
     618        hr = pEnumDevices->Next(5000, 20, pDevices, &uReturned);
     619        if( FAILED(hr) )
     620            goto LCleanup;
     621
     622        if( uReturned == 0 )
     623            break;
     624
     625        for(iDevice = 0; iDevice < uReturned; iDevice++)
     626        {
     627            // For each device, get its device ID
     628            hr = pDevices[iDevice]->Get(bstrDeviceID, 0L, &var, NULL, NULL);
     629            if(SUCCEEDED(hr) && var.vt == VT_BSTR && var.bstrVal != NULL)
     630            {
     631                // Check if the device ID contains "IG_".  If it does, then it's an XInput device - This information can not be found from DirectInput
     632                if(wcsstr(var.bstrVal, L"IG_"))
     633                {
     634                    // If it does, then get the VID/PID from var.bstrVal
     635                    DWORD dwPid = 0, dwVid = 0;
     636                    WCHAR* strVid = wcsstr( var.bstrVal, L"VID_" );
     637                    if(strVid && swscanf_s( strVid, L"VID_%4X", &dwVid ) != 1)
     638                                                dwVid = 0;
     639
     640                    WCHAR* strPid = wcsstr( var.bstrVal, L"PID_" );
     641                    if(strPid && swscanf_s( strPid, L"PID_%4X", &dwPid ) != 1)
     642                        dwPid = 0;
     643
     644                    // Compare the VID/PID to the DInput device
     645                    DWORD dwVidPid = MAKELONG(dwVid, dwPid);
     646                                        for(JoyStickInfoList::iterator i = joys.begin(); i != joys.end(); ++i)
     647                                        {
     648                                                if(dwVidPid == i->productGuid.Data1)
     649                                                {
     650                                                        i->isXInput = true;
     651                                                        i->xInputDev = xDevice;
     652                                                }
     653                                        }
     654
     655                                        if(joys.size() == 0)
     656                                                goto LCleanup;
     657                }
     658            }
     659
     660            SAFE_RELEASE(pDevices[iDevice]);
     661        }
     662    }
     663
     664LCleanup:
     665    if(bstrNamespace)
     666        SysFreeString(bstrNamespace);
     667
     668    if(bstrDeviceID)
     669        SysFreeString(bstrDeviceID);
     670
     671    if(bstrClassName)
     672        SysFreeString(bstrClassName);
     673
     674    for(iDevice=0; iDevice < 20; iDevice++)
     675        SAFE_RELEASE(pDevices[iDevice]);
     676
     677    SAFE_RELEASE(pEnumDevices);
     678    SAFE_RELEASE(pIWbemLocator);
     679    SAFE_RELEASE(pIWbemServices);
     680
     681    if(bCleanupCOM)
     682        CoUninitialize();
     683}
  • code/branches/ois_update/src/external/ois/win32/Win32JoyStick.h

    r5781 r7506  
    2525
    2626#include "OISJoyStick.h"
    27 #include "Win32/Win32Prereqs.h"
     27#include "win32/Win32Prereqs.h"
    2828
    2929namespace OIS
     
    4141                virtual void capture();
    4242
     43                //! hanlde xinput
     44                void captureXInput();
     45
    4346                /** @copydoc Object::queryInterface */
    4447                virtual Interface* queryInterface(Interface::IType type);
     
    4649                /** @copydoc Object::_initialize */
    4750                virtual void _initialize();
     51
     52                /**
     53                @remarks
     54                        Enum each PNP device using WMI and check each device ID to see if it contains
     55                        "IG_" (ex. "VID_045E&PID_028E&IG_00").  If it does, then it's an XInput device
     56                        Unfortunately this information can not be found by just using DirectInput
     57                */
     58                static void CheckXInputDevices(JoyStickInfoList &joys);
    4859
    4960        protected:
     
    6172                IDirectInputDevice8* mJoyStick;
    6273                DIDEVCAPS mDIJoyCaps;
     74                DWORD coopSetting;
    6375
    64                 DWORD coopSetting;
    65                 GUID deviceGuid;
     76        JoyStickInfo mJoyInfo;
    6677
    6778                //! A force feedback device
    68                 Win32ForceFeedback* ff_device;
     79                Win32ForceFeedback* mFfDevice;
    6980
    7081                //! Mapping
  • code/branches/ois_update/src/external/ois/win32/Win32KeyBoard.cpp

    r5781 r7506  
    2121    3. This notice may not be removed or altered from any source distribution.
    2222*/
    23 #include "Win32/Win32InputManager.h"
    24 #include "Win32/Win32KeyBoard.h"
     23#include "win32/Win32InputManager.h"
     24#include "win32/Win32KeyBoard.h"
    2525#include "OISException.h"
    2626#include "OISEvents.h"
     
    287287
    288288//--------------------------------------------------------------------------------------------------//
    289 const std::string& Win32Keyboard::getAsString( KeyCode kc )
     289const std::string& Win32Keyboard::getAsString(KeyCode kc)
    290290{
    291291        char temp[256];
     
    297297        prop.diph.dwHow = DIPH_BYOFFSET;
    298298
    299         if ( SUCCEEDED( mKeyboard->GetProperty( DIPROP_KEYNAME, &prop.diph ) ) )
     299        if (SUCCEEDED(mKeyboard->GetProperty(DIPROP_KEYNAME, &prop.diph)))
    300300        {
    301301                // convert the WCHAR in "wsz" to multibyte
    302                 if ( WideCharToMultiByte( CP_ACP, 0, prop.wsz, -1, temp, sizeof(temp), NULL, NULL) )
    303                         return mGetString.assign( temp );
     302                if (WideCharToMultiByte(CP_ACP, 0, prop.wsz, -1, temp, sizeof(temp), NULL, NULL))
     303                        return mGetString.assign(temp);
    304304        }
    305305
    306306        std::stringstream ss;
    307307        ss << "Key_" << (int)kc;
    308         return mGetString.assign( ss.str() );
     308        return mGetString.assign(ss.str());
    309309}
    310310
  • code/branches/ois_update/src/external/ois/win32/Win32KeyBoard.h

    r5781 r7506  
    2525
    2626#include "OISKeyboard.h"
    27 #include "Win32/Win32Prereqs.h"
     27#include "win32/Win32Prereqs.h"
    2828
    2929namespace OIS
     
    4242                        A combination of DI Flags (see DX Help for info on input device settings)
    4343                */
    44                 Win32Keyboard( InputManager* creator, IDirectInput8* pDI, bool buffered, DWORD coopSettings );
     44                Win32Keyboard(InputManager* creator, IDirectInput8* pDI, bool buffered, DWORD coopSettings);
    4545                virtual ~Win32Keyboard();
    4646
    4747                /** @copydoc Keyboard::isKeyDown */
    48                 virtual bool isKeyDown( KeyCode key ) const;
     48                virtual bool isKeyDown(KeyCode key) const;
    4949               
    5050                /** @copydoc Keyboard::getAsString */
    51                 virtual const std::string& getAsString( KeyCode kc );
     51                virtual const std::string& getAsString(KeyCode kc);
    5252
    5353                /** @copydoc Keyboard::copyKeyStates */
    54                 virtual void copyKeyStates( char keys[256] ) const;
     54                virtual void copyKeyStates(char keys[256]) const;
    5555
    5656                /** @copydoc Object::setBuffered */
  • code/branches/ois_update/src/external/ois/win32/Win32Mouse.cpp

    r5781 r7506  
    2121    3. This notice may not be removed or altered from any source distribution.
    2222*/
    23 #include "Win32/Win32Mouse.h"
    24 #include "Win32/Win32InputManager.h"
     23#include "win32/Win32Mouse.h"
     24#include "win32/Win32InputManager.h"
    2525#include "OISException.h"
    2626#include "OISEvents.h"
  • code/branches/ois_update/src/external/ois/win32/Win32Mouse.h

    r5781 r7506  
    2525
    2626#include "OISMouse.h"
    27 #include "Win32/Win32Prereqs.h"
     27#include "win32/Win32Prereqs.h"
    2828
    2929namespace OIS
  • code/branches/ois_update/src/external/ois/win32/Win32Prereqs.h

    r5781 r7506  
    2929#include <dinput.h>
    3030
     31#ifdef OIS_WIN32_XINPUT_SUPPORT
     32#       include <XInput.h>
     33#endif
     34
    3135//Max number of elements to collect from buffered DirectInput
    3236#define KEYBOARD_DX_BUFFERSIZE 17
    33 #define MOUSE_DX_BUFFERSIZE 64
    34 #define JOYSTICK_DX_BUFFERSIZE 124
     37#define MOUSE_DX_BUFFERSIZE 128
     38#define JOYSTICK_DX_BUFFERSIZE 129
    3539
    3640//MinGW defines
     
    5559                int devId;
    5660                GUID deviceID;
     61                GUID productGuid;
    5762                std::string vendor;
     63        bool isXInput;
     64                int xInputDev;
    5865        };
    5966
    60         typedef std::vector< JoyStickInfo > JoyStickInfoList;
     67        typedef std::vector<JoyStickInfo> JoyStickInfoList;
    6168}
    6269
Note: See TracChangeset for help on using the changeset viewer.