source: code/branches/kicklib/src/external/ois/linux/LinuxJoyStickEvents.cpp @ 8474

/*
The zlib/libpng License

Copyright (c) 2005-2007 Phillip Castaneda (pjcast -- www.wreckedgames.com)

This software is provided 'as-is', without any express or implied warranty. In no event will
the authors be held liable for any damages arising from the use of this software.

Permission is granted to anyone to use this software for any purpose, including commercial
applications, and to alter it and redistribute it freely, subject to the following
restrictions:

    1. The origin of this software must not be misrepresented; you must not claim that
                you wrote the original software. If you use this software in a product,
                an acknowledgment in the product documentation would be appreciated but is
                not required.

    2. Altered source versions must be plainly marked as such, and must not be
                misrepresented as being the original software.

    3. This notice may not be removed or altered from any source distribution.
*/
#include "OISConfig.h"

#include "linux/LinuxJoyStickEvents.h"
#include "linux/LinuxInputManager.h"
#include "linux/LinuxForceFeedback.h"
#include "linux/EventHelpers.h"

#include "OISEvents.h"
#include "OISException.h"

#include <fcntl.h>        //Needed to Open a file descriptor
#include <cassert>      
#include <linux/input.h>


#include <sstream>
# include <iostream>
using namespace std;

using namespace OIS;

//#define OIS_LINUX_JOY_DEBUG

//-------------------------------------------------------------------//
LinuxJoyStick::LinuxJoyStick(InputManager* creator, bool buffered, const JoyStickInfo& js)
        : JoyStick(js.vendor, buffered, js.devId, creator)
{
        mJoyStick = js.joyFileD;

        mState.mAxes.clear();
        mState.mAxes.resize(js.axes);
        mState.mButtons.clear();
        mState.mButtons.resize(js.buttons);

        mPOVs = js.hats;

        mButtonMap = js.button_map;
        mAxisMap = js.axis_map;
        mRanges = js.axis_range;

        ff_effect = 0;
}

//-------------------------------------------------------------------//
LinuxJoyStick::~LinuxJoyStick()
{
        EventUtils::removeForceFeedback( &ff_effect );
}

//-------------------------------------------------------------------//
void LinuxJoyStick::_initialize()
{
        //Clear old joy state
        mState.mAxes.resize(mAxisMap.size());
        mState.clear();

        //This will create and new us a force feedback structure if it exists
        EventUtils::enumerateForceFeedback( mJoyStick, &ff_effect );

        if( mJoyStick == -1 )
                OIS_EXCEPT(E_InputDeviceNonExistant, "LinuxJoyStick::_initialize() >> JoyStick Not Found!");
}

//-------------------------------------------------------------------//
void LinuxJoyStick::capture()
{
        static const short POV_MASK[8] = {0,0,1,1,2,2,3,3};

        //Used to determine if an axis has been changed and needs an event
        bool axisMoved[32] = {false, false, false, false, false, false, false, false, false, false, false, false, false,
                                                  false, false, false, false, false, false, false, false, false, false, false, false, false,
                                                  false, false, false, false, false, false};

        //We are in non blocking mode - we just read once, and try to fill up buffer
        input_event js[JOY_BUFFERSIZE];
        while(true)
        {
                int ret = read(mJoyStick, &js, sizeof(struct input_event) * JOY_BUFFERSIZE);
        if( ret < 0 )
                        break;

                //Determine how many whole events re read up
                ret /= sizeof(struct input_event);
                for(int i = 0; i < ret; ++i)
                {
                        switch(js[i].type)
                        {
                        case EV_KEY:  //Button
                        {
                                int button = mButtonMap[js[i].code];

                                #ifdef OIS_LINUX_JOY_DEBUG
                                  cout << "\nButton Code: " << js[i].code << ", OIS Value: " << button << endl;
                                #endif

                                //Check to see whether push or released event...
                                if(js[i].value)
                                {
                                        mState.mButtons[button] = true;
                                        if( mBuffered && mListener )
                                                if(!mListener->buttonPressed(JoyStickEvent(this,mState), button)) return;
                                }
                                else
                                {
                                        mState.mButtons[button] = false;
                                        if( mBuffered && mListener )
                                                if(!mListener->buttonReleased(JoyStickEvent(this,mState), button)) return;
                                }
                                break;
                        }

                        case EV_ABS:  //Absolute Axis
                        {
                                //A Stick (BrakeDefine is the highest possible Axis)
                                if( js[i].code <= ABS_BRAKE )
                                {
                                        int axis = mAxisMap[js[i].code];
                                        assert( axis < 32 && "Too many axes (Max supported is 32). Report this to OIS forums!" );

                                        axisMoved[axis] = true;

                                        //check for rescaling:
                                        if( mRanges[axis].min == JoyStick::MIN_AXIS && mRanges[axis].max != JoyStick::MAX_AXIS )
                                        {       //Scale is perfect
                                                mState.mAxes[axis].abs = js[i].value;
                                        }
                                        else
                                        {       //Rescale
                                                float proportion = (float)(js[i].value-mRanges[axis].max)/(float)(mRanges[axis].min-mRanges[axis].max);
                                                mState.mAxes[axis].abs = (int)(32767.0f - (65535.0f * proportion));
                                        }
                                }
                                else if( js[i].code <= ABS_HAT3Y ) //A POV - Max four POVs allowed
                                {
                                        //Normalise the POV to between 0-7
                                        //Even is X Axis, Odd is Y Axis
                                        unsigned char LinuxPovNumber = js[i].code - 16;
                                        short OIS_POVIndex = POV_MASK[LinuxPovNumber];

                                        //Handle X Axis first (Even) (left right)
                                        if((LinuxPovNumber & 0x0001) == 0)
                                        {
                                                //Why do this? Because, we use a bit field, and when this axis is east,
                                                //it can't possibly be west too. So clear out the two X axes, then refil
                                                //it in with the new direction bit.
                                                //Clear the East/West Bit Flags first
                                                mState.mPOV[OIS_POVIndex].direction &= 0x11110011;
                                                if( js[i].value == -1 ) //Left
                                                        mState.mPOV[OIS_POVIndex].direction |= Pov::West;
                                                else if( js[i].value == 1 ) //Right
                                                        mState.mPOV[OIS_POVIndex].direction |= Pov::East;
                                        }
                                        //Handle Y Axis (Odd) (up down)
                                        else
                                        {
                                                //Clear the North/South Bit Flags first
                                                mState.mPOV[OIS_POVIndex].direction &= 0x11111100;
                                                if( js[i].value == -1 ) //Up
                                                        mState.mPOV[OIS_POVIndex].direction |= Pov::North;
                                                else if( js[i].value == 1 ) //Down
                                                        mState.mPOV[OIS_POVIndex].direction |= Pov::South;
                                        }

                                        if( mBuffered && mListener )
                                                if( mListener->povMoved( JoyStickEvent(this,mState), OIS_POVIndex) == false )
                                                        return;
                                }
                                break;
                        }

                        
                        case EV_REL: //Relative Axes (Do any joystick actually have a relative axis?)
        #ifdef OIS_LINUX_JOY_DEBUG
                                cout << "\nWarning: Relatives axes not supported yet" << endl;
        #endif
                                break;
                        default: break;
                        }
                }
        }

        //All axes and POVs are combined into one movement per pair per captured frame
        if( mBuffered && mListener )
        {
                for( int i = 0; i < 32; ++i )
                        if( axisMoved[i] )
                                if( mListener->axisMoved( JoyStickEvent(this,mState), i) == false )
                                        return;
        }
}

//-------------------------------------------------------------------//
void LinuxJoyStick::setBuffered(bool buffered)
{
        if( buffered != mBuffered )
        {
                mBuffered = buffered;
                _initialize();
        }
}

//-------------------------------------------------------------------//
JoyStickInfo LinuxJoyStick::_getJoyInfo()
{
        JoyStickInfo js;

        js.devId = mDevID;
        js.joyFileD = mJoyStick;
        js.vendor = mVendor;
        js.axes = (int)mState.mAxes.size();
        js.buttons = (int)mState.mButtons.size();
        js.hats = mPOVs;
        js.button_map = mButtonMap;
        js.axis_map = mAxisMap;
        js.axis_range = mRanges;

        return js;
}

//-------------------------------------------------------------------//
JoyStickInfoList LinuxJoyStick::_scanJoys()
{
        JoyStickInfoList joys;

        //Search through all of the event devices.. and identify which ones are joysticks
        //xxx move this to InputManager, as it can also scan all other events
        for(int i = 0; i < 64; ++i )
        {
                stringstream s;
                s << "/dev/input/event" << i;
                int fd = open( s.str().c_str(), O_RDWR |O_NONBLOCK );
                if(fd == -1)
                        continue;

        #ifdef OIS_LINUX_JOY_DEBUG
                  cout << "Opening " << s.str() << "..." << endl;
        #endif
                try
                {
                        JoyStickInfo js;
                        if( EventUtils::isJoyStick(fd, js) )
                        {
                                joys.push_back(js);
                #ifdef OIS_LINUX_JOY_DEBUG
                  cout << "=> Joystick added to list." << endl;
                #endif
                        }
                        else
                        {
                #ifdef OIS_LINUX_JOY_DEBUG
                  cout << "=> Not a joystick." << endl;
                #endif
                                close(fd);
                        }
                }
                catch(...)
                {
            #ifdef OIS_LINUX_JOY_DEBUG
              cout << "Exception caught!!" << endl;
            #endif
                        close(fd);
                }
        }

        return joys;
}

//-------------------------------------------------------------------//
void LinuxJoyStick::_clearJoys(JoyStickInfoList &joys)
{
        for(JoyStickInfoList::iterator i = joys.begin(); i != joys.end(); ++i)
                close(i->joyFileD);
        joys.clear();
}

//-------------------------------------------------------------------//
Interface* LinuxJoyStick::queryInterface(Interface::IType type)
{
        if( ff_effect && type == Interface::ForceFeedback )
                return ff_effect;

        return 0;
}