GASProtoMapper.cpp

Go to the documentation of this file.

/// \file    GASProtoMapper.cpp
/// \brief   Maps inputs from a controller to various outputs
/// \ingroup CAT
///
/// Copyright (c) 2008 by Michael Ellison.
/// See COPYING.txt for the \ref gaslicense License (MIT License).
///
// $Author: mikeellison $
// $Date: 2008-02-01 03:19:21 -0600 (Fri, 01 Feb 2008) $
// $Revision:   $
// $NoKeywords: $

#include "GASProtoMapper.h"
#include "CATDirectInput.h"
#include "CATDIJoystick.h"

GASProtoMapper::GASProtoMapper()
{
    fDirectInput = 0;
    fController  = 0;
    fMap         = 0;
    fPollFreq    = 50;
    fValidAxis   = 0;
    fFilterXLow  = 0;
    fFilterXHigh = 0;
    fFilterZLow  = 0;
    fFilterZHigh = 0;
    fFilterXRotLow = 0;
    fFilterXRotHigh = 0;
    fFilterYRotLow = 0;
    fFilterYRotHigh = 0;
    fCToggle = false;
    fLSToggle = false;
    fLCToggle = false;
    fWPovKeyDown = false;
    fSPovKeyDown = false;
    fWKeyDown = false;
    fSKeyDown = false;
    fAKeyDown = false;
    fDKeyDown = false;
    fSpeedToggle = false;
    fInitialized = false;
}

GASProtoMapper::~GASProtoMapper()
{
    if (fInitialized)
        (void)Uninitialize();
}

CATResult GASProtoMapper::Initialize()
{
    if (fInitialized)
        return CAT_SUCCESS;
    
    CATResult result;

    fDirectInput = new CATDirectInput();
    result = fDirectInput->Init();
    if (CATFAILED(result))
        Uninitialize();
    else
        fInitialized = true;

    return result;
}

CATResult GASProtoMapper::Uninitialize()
{
    StopMapping();

    if (fDirectInput)
    {
        delete fDirectInput;
        fDirectInput = 0;
    }
    if (fFilterXLow)
    {
        delete fFilterXLow;
        fFilterXLow = 0;
    }
    if (fFilterXHigh)
    {
        delete fFilterXHigh;
        fFilterXHigh = 0;
    }
    if (fFilterZLow)
    {
        delete fFilterZLow;
        fFilterZLow = 0;
    }
    if (fFilterZHigh)
    {
        delete fFilterZHigh;
        fFilterZHigh = 0;
    }
    if (fFilterXRotLow)
    {
        delete fFilterXRotLow;
        fFilterXRotLow = 0;
    }
    if (fFilterXRotHigh)
    {
        delete fFilterXRotHigh;
        fFilterXRotHigh = 0;
    }
    if (fFilterYRotLow)
    {
        delete fFilterYRotLow;
        fFilterYRotLow = 0;
    }
    if (fFilterYRotHigh)
    {
        delete fFilterYRotHigh;
        fFilterYRotHigh = 0;
    }

    fInitialized = false;
    return CAT_SUCCESS;
}


void JoystickListCB(const CATWChar* name, void* userParam)
{
    std::vector<CATString>* joystickList = (std::vector<CATString>*)userParam;
    joystickList->push_back(name);
}


CATResult GASProtoMapper::GetControllerList( std::vector<CATString>& controllerList )
{
    if (!fInitialized)
        return CATRESULT(CAT_ERR_NOT_INITIALIZED);

    fDirectInput->EnumJoysticks(JoystickListCB,&controllerList);    
    
    return CAT_SUCCESS;
}

CATResult GASProtoMapper::GetMappingList(    const CATString&        controllerName,
                                             std::vector<CATString>& mappingList)
{
    return CAT_SUCCESS;
}

CATResult GASProtoMapper::StartMapping(      const CATString&        controllerName,
                                             const CATString&        mappingName)
{
    fController = fDirectInput->CreateJoystick(controllerName);    
    
    if (!fController)
        return CAT_ERROR;

    fValidAxis = fController->GetValidAxis();

    fController->GetStatus(fLastStatus);
    fMap = new CATControlMap();

    if (fFilterXLow)
        fFilterXLow->Reset();
    else
        fFilterXLow = new CATFilterAttackDecay(0.99f,0.1f);

    if (fFilterXHigh)
        fFilterXHigh->Reset();
    else
        fFilterXHigh = new CATFilterAttackDecay(0.99f,0.1f);

    if (fFilterZLow)
        fFilterZLow->Reset();
    else
        fFilterZLow = new CATFilterAttackDecay(0.99f,0.01f);

    if (fFilterZHigh)
        fFilterZHigh->Reset();
    else
        fFilterZHigh = new CATFilterAttackDecay(0.99f,0.01f);

    if (fFilterXRotLow)
        fFilterXRotLow->Reset();
    else
        fFilterXRotLow = new CATFilterAttackDecay(0.99f,0.01f);

    if (fFilterXRotHigh)
        fFilterXRotHigh->Reset();
    else
        fFilterXRotHigh = new CATFilterAttackDecay(0.99f,0.01f);

    if (fFilterYRotLow)
        fFilterYRotLow->Reset();
    else
        fFilterYRotLow = new CATFilterAttackDecay(0.99f,0.01f);

    if (fFilterYRotHigh)
        fFilterYRotHigh->Reset();
    else
        fFilterYRotHigh = new CATFilterAttackDecay(0.99f,0.01f);

    this->Start(fPollFreq);

    return CAT_SUCCESS;
}

CATResult GASProtoMapper::StopMapping()
{
    this->Stop();

    if (fController)
    {
        delete fController;
        fController = 0;
    }

    if (fMap)
    {
        delete fMap;
        fMap = 0;
    }
    return CAT_SUCCESS;
}


void GASProtoMapper::OnThreadIdle()
{
    if (fController)
    {
        CATJOYSTICKSTRUCT status;

        if (fController->GetStatus(status))
        {
            for (CATUInt32 i = 0; i < kCATJOYSTICKBTNMAX; i++)
            {
                if ((status.buttonMap & (1 << i)) != (fLastStatus.buttonMap & (1 << i)))    
                {
                    OnButtonChange( 0 != (status.buttonMap & (1 << i)), i);
                }
            }

            // Oh yeah... for mice, axis doesn't need to change for us
            // to update position. doh. Just call direct.
            OnAxis(status.xHigh,    CATJoystick::X_AXIS_HIGH);
            OnAxis(status.xLow,     CATJoystick::X_AXIS_LOW);
            OnAxis(status.xRot,     CATJoystick::X_ROT);
            OnAxis(status.xRotLow,  CATJoystick::X_ROT_LOW);
            OnAxis(status.xRotHigh, CATJoystick::X_ROT_HIGH);
            OnAxis(status.yAxis,    CATJoystick::Y_AXIS);
            OnAxis(status.yRot,     CATJoystick::Y_ROT);
            OnAxis(status.yRotLow,  CATJoystick::Y_ROT_LOW);
            OnAxis(status.yRotHigh, CATJoystick::Y_ROT_HIGH);
            OnAxis(status.zAxis,    CATJoystick::Z_AXIS);
            OnAxis(status.zHigh,    CATJoystick::Z_AXIS_HIGH);
            OnAxis(status.zLow,     CATJoystick::Z_AXIS_LOW);
            OnAxis(status.zRot,     CATJoystick::Z_ROT);
            OnAxis(status.zRotLow,  CATJoystick::Z_ROT_LOW);
            OnAxis(status.zRotHigh, CATJoystick::Z_ROT_HIGH);
            OnAxis(status.xPov,     CATJoystick::X_POV);
            OnAxis(status.yPov,     CATJoystick::Y_POV);

            fLastStatus = status;           
/*
            CATString dbg;
            dbg.Format(L"x:%03d y:%03d z:%03d rx:%03d ry:%03d rz:%03d\n",
                status.xAxis, status.yAxis, status.zAxis, 
                status.xRot,  status.yRot,  status.zRot);
            ::OutputDebugString(dbg);
*/
        
        }

    }
}

CATUInt32 GASProtoMapper::OnThreadMessage(CATUInt32 msg, CATUInt32 wParam, CATUInt32 lParam)
{
    return 0;
}

void GASProtoMapper::OnAxis(CATInt32 val, CATJoystick::AXIS_TYPE axisType)
{
    // Abstracting this the second I get a controller fully mapped out. seriously.
    CATInt32 xChange, yChange, wChange;
    xChange = yChange = wChange = 0;

    CATFloat32 sensitivity = 1.0f;
    CATInt32   xThresh     = 14;
    CATInt32   yThresh     = 14;

    switch (axisType)
    {
        case CATJoystick::X_AXIS_LOW:
            {
                if (abs(val) < xThresh)
                    val = 0;

                xChange = -fFilterXLow->Filter(val)* sensitivity;
                mouse_event(MOUSEEVENTF_MOVE, xChange, 0, 0, 0);                
            }
            break;
        case CATJoystick::X_AXIS_HIGH:                
            {
                if (abs(val) < xThresh)
                    val = 0;

                xChange = fFilterXHigh->Filter(val)* sensitivity;
                mouse_event(MOUSEEVENTF_MOVE, xChange, 0, 0, 0);                
            }
            break;

        case CATJoystick::Y_POV:
            {
                if (val > 50+yThresh)
                {
                    if (!fSPovKeyDown)
                    {
                        fSPovKeyDown = true;
                        PushChar(DIKEYBOARD_S,true);
                    }
                    
                    if (fWPovKeyDown)
                    {
                        fWPovKeyDown = false;
                        PushChar(DIKEYBOARD_W,false);
                        // send W up
                    }
                }
                else if (val < 50-yThresh)
                {
                    if (!fWPovKeyDown)
                    {
                        fWPovKeyDown = true;                        
                        PushChar(DIKEYBOARD_W,true);
                    }
                    
                    if (fSPovKeyDown)
                    {
                        fSPovKeyDown = false;
                        PushChar(DIKEYBOARD_S,false);
                        // send S up
                    }
                }
                else
                {
                    if (fSPovKeyDown)
                    {
                        fSPovKeyDown = false;
                        PushChar(DIKEYBOARD_S,false);
                        // S up
                    }
                    if (fWPovKeyDown)
                    {
                        fWPovKeyDown = false;
                        PushChar(DIKEYBOARD_W,false);
                        // W up
                    }
                }
            }
            break;

        case CATJoystick::Y_AXIS:
            {
                if (val > 50+yThresh)
                {
                    if (!fSKeyDown)
                    {
                        fSKeyDown = true;
                        PushChar(DIKEYBOARD_S,true);
                    }
                    
                    if (fWKeyDown)
                    {
                        fWKeyDown = false;
                        PushChar(DIKEYBOARD_W,false);
                        // send W up
                    }
                }
                else if (val < 50-yThresh)
                {
                    if (!fWKeyDown)
                    {
                        fWKeyDown = true;                        
                        PushChar(DIKEYBOARD_W,true);
                    }
                    
                    if (fSKeyDown)
                    {
                        fSKeyDown = false;
                        PushChar(DIKEYBOARD_S,false);
                        // send S up
                    }
                }
                else
                {
                    if (fSKeyDown)
                    {
                        fSKeyDown = false;
                        PushChar(DIKEYBOARD_S,false);
                        // S up
                    }
                    if (fWKeyDown)
                    {
                        fWKeyDown = false;
                        PushChar(DIKEYBOARD_W,false);
                        // W up
                    }
                }
            }
            break;
        case CATJoystick::X_POV:
            {
                if (val > 50+xThresh)
                {
                    if (!fAKeyDown)
                    {
                        fAKeyDown = true;
                        PushChar(DIKEYBOARD_A,true);
                    }
                    
                    if (fDKeyDown)
                    {
                        fDKeyDown = false;
                        PushChar(DIKEYBOARD_D,false);                                                
                    }
                }
                else if (val < 50-xThresh)
                {
                    if (!fDKeyDown)
                    {
                        fDKeyDown = true;                        
                        PushChar(DIKEYBOARD_D,true);
                    }
                    
                    if (fAKeyDown)
                    {
                        fAKeyDown = false;
                        PushChar(DIKEYBOARD_A,false);                        
                    }
                }
                else
                {
                    if (fAKeyDown)
                    {
                        fAKeyDown = false;
                        PushChar(DIKEYBOARD_A,false);
                    }
                    if (fDKeyDown)
                    {
                        fDKeyDown = false;
                        PushChar(DIKEYBOARD_D,false);                        
                    }
                }
            }
            break;


        case CATJoystick::Z_AXIS_LOW:
            {
                if (abs(val) < yThresh)
                    val = 0;

                yChange = -fFilterZLow->Filter(val)* sensitivity;
                mouse_event(MOUSEEVENTF_MOVE, 0, yChange, 0, 0);
            }
            break;
        case CATJoystick::Z_AXIS_HIGH:
            {
                if (abs(val) < yThresh)
                    val = 0;
                yChange = fFilterZHigh->Filter(val)* sensitivity;
                mouse_event(MOUSEEVENTF_MOVE, 0, yChange, 0, 0);
            }
            break;


        case CATJoystick::X_ROT_LOW:
            {
                if (abs(val) < xThresh)
                    val = 0;

                xChange = -fFilterXRotLow->Filter(val)* sensitivity;
                mouse_event(MOUSEEVENTF_MOVE, xChange, 0, 0, 0);                
            }
            break;
        case CATJoystick::X_ROT_HIGH:                
            {
                if (abs(val) < xThresh)
                    val = 0;

                xChange = fFilterXRotHigh->Filter(val)* sensitivity;
                mouse_event(MOUSEEVENTF_MOVE, xChange, 0, 0, 0);                
            }
            break;
        case CATJoystick::Y_ROT_LOW:
            {
                if (abs(val) < yThresh)
                    val = 0;

                yChange = -fFilterYRotLow->Filter(val)* sensitivity;
                mouse_event(MOUSEEVENTF_MOVE, 0, yChange, 0, 0);
            }
            break;
        case CATJoystick::Y_ROT_HIGH:
            {
                if (abs(val) < yThresh)
                    val = 0;
                yChange = fFilterYRotHigh->Filter(val)* sensitivity;
                mouse_event(MOUSEEVENTF_MOVE, 0, yChange, 0, 0);
            }
            break;
    }

}


void GASProtoMapper::OnButtonChange(bool state, CATUInt32 button)
{       
    enum QUADCONTROL_BUTTONS
    {
        QC_LOWERLEFT  = 0,
        QC_CENTERSIP  = 1,
        QC_CENTERPUFF = 2,
        QC_UPPERLEFT  = 3,
        QC_LEFTPUFF   = 4,
        QC_RIGHTPUFF  = 5,
        QC_STARTSIP   = 6,
        QC_STARTPUFF  = 7,
        QC_LEFTSIP    = 8,
        QC_RIGHTSIP   = 9,
        QC_UPPERRIGHT = 10, // ? unused ?
        
        //
        QC_X = 0x7fffffff
    };

    CATString dbg;
    dbg.Format(L"Button: %d state: %d\n",button,state?1:0);
    ::OutputDebugString(dbg);
    switch (button)
    {
        case QC_LOWERLEFT:
            if (state)
            {
                if (fSpeedToggle)
                    PushChar(DIKEYBOARD_F13,true);
                else
                    PushChar(DIKEYBOARD_F14,true);
            }
            else
            {
                if (fSpeedToggle)
                    PushChar(DIKEYBOARD_F13,false);
                else
                    PushChar(DIKEYBOARD_F14,false);

                fSpeedToggle ^= 1;
            }
            break;
        case QC_CENTERSIP:
            if (state)
            {
                mouse_event( MOUSEEVENTF_RIGHTDOWN,0,0,0,0);
            }
            else
            {
                mouse_event( MOUSEEVENTF_RIGHTUP,0,0,0,0);
            }
            break;
        case QC_CENTERPUFF:
            if (state)
            {
                mouse_event( MOUSEEVENTF_LEFTDOWN,0,0,0,0);
            }
            else
            {
                mouse_event( MOUSEEVENTF_LEFTUP,0,0,0,0);
            }

            break;
        case QC_UPPERLEFT:
            PushChar(DIKEYBOARD_F,state);
            break;
        case QC_LEFTPUFF:
            if (state)
            {
                if (fCToggle)
                {
                    PushChar(DIKEYBOARD_C,true);
                }
                else
                {
                    PushChar(DIKEYBOARD_C,false);
                }
                fCToggle ^= 1;
            }
            PushChar(DIKEYBOARD_R,state);
            break;
        case QC_RIGHTPUFF:
            if (state)
            {
                if (fLSToggle)
                {
                    PushChar(DIKEYBOARD_LSHIFT,true);
                }
                else
                {
                    PushChar(DIKEYBOARD_LSHIFT,false);                    
                }
                fLSToggle ^= 1;
            }
            break;
        case QC_STARTSIP:
            // Reset all currently down keys on escape...
            PushChar(DIKEYBOARD_ESCAPE,state);
            {
                if (fWKeyDown || fWPovKeyDown)
                {
                    PushChar(DIKEYBOARD_W,false);
                    fWKeyDown = false;
                    fWPovKeyDown = false;
                }
                if (fSKeyDown || fSKeyDown)
                {
                    PushChar(DIKEYBOARD_S,false);
                    fSKeyDown = false;
                    fSPovKeyDown = false;
                }
                if (fAKeyDown)
                {
                    PushChar(DIKEYBOARD_A,false);
                    fAKeyDown = false;
                }
                if (fDKeyDown)
                {
                    PushChar(DIKEYBOARD_D,false);
                    fDKeyDown = false;
                }
                if (fSpeedToggle)
                {
                    PushChar(DIKEYBOARD_F14,true);
                    PushChar(DIKEYBOARD_F14,false);
                    fSpeedToggle = false;
                }
                if (fCToggle)
                {
                    PushChar(DIKEYBOARD_C,false);
                    fCToggle = false;
                }
                if (fLSToggle)
                {
                    PushChar(DIKEYBOARD_LSHIFT,false);
                    fLSToggle = false;
                }
                if (fLCToggle)
                {
                    PushChar(DIKEYBOARD_LCONTROL,false);
                    fLCToggle = false;
                }
            }
            
            break;
        case QC_STARTPUFF:
            PushChar(DIKEYBOARD_TAB,state);
            Sleep(100);
            PushChar(DIKEYBOARD_E,state);
            break;
        case QC_LEFTSIP:            
            if (state)
            {
                mouse_event(MOUSEEVENTF_WHEEL | MOUSEEVENTF_ABSOLUTE, 0,0, WHEEL_DELTA, 0);
            }            
            break;
        case QC_RIGHTSIP:
            if (state)
            {
                if (fLCToggle)
                {
                    PushChar(DIKEYBOARD_LCONTROL,true);
                }
                else
                {
                    PushChar(DIKEYBOARD_LCONTROL,false);                    
                }
                fLCToggle ^= 1;
            }            
            break;
    }       
}

void GASProtoMapper::PushChar(CATUInt32 scanCode, bool keydown)
{
    INPUT input;
    input.type = INPUT_KEYBOARD;
    input.ki.dwExtraInfo = 0;
    input.ki.dwFlags = KEYEVENTF_SCANCODE | (keydown ? 0 : KEYEVENTF_KEYUP);
    input.ki.wScan = scanCode;
    input.ki.wVk = 0;
    input.ki.time = 0;
    SendInput(1,&input,sizeof(INPUT));
}

---