direct-input.cpp

Go to the documentation of this file.

/*
 * direct-input.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Input support built on the Microsoft DirectX DirectInput APIs
 */

// includes --------------------------------------------------------------------
#include "direct-input.h"               // always include our own header first
#include "di-diagnostics.h"

#include "perf/perf.h"
#include "wave-windows/wave-windows.h"  // wavepacket windows helper library

#include <iostream>


namespace gamepad {


// TODO: is this defined already somewhere in a DirectInput header?
// this is the constant we need to decipher POV values
static const int s_FortyFiveDegreesValue = 4500;


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
//
//      DirectInputDevice -- class that implements the gamepad::SourceDevice
//              interface for Microsoft DirectInput devices.
//
////////////////////////////////////////////////////////////////////////////////

class DirectInputDevice : public SourceDevice {
public:
        // constructor, destructor ---------------------------------------------
        DirectInputDevice(void) throw();
        ~DirectInputDevice(void) throw();

        // public class methods ------------------------------------------------
        // gamepad::SourceDevice class interface methods -----------------------
        virtual const char * getPublicName(void) throw() { return m_name.c_str(); }
        virtual const char * getUniqueId(void) throw() { return m_id.c_str(); }
        virtual eDeviceState getState(void) throw();
        virtual int getNumPots(void) throw() { return m_dcaps.nAxes; }
        virtual int getNumButtons(void) throw() { return m_dcaps.nButtons; }
        virtual int getNumRumblers(void) throw() { return 0; }
        virtual void poll(void) throw();
        virtual const pot_value_t& getPotValue(IN int potIndex);
        virtual eButton getButtonValue(IN int buttonIndex);
        virtual bool playRumble(IN int rumbleIndex,
                                IN uint16_t highFreqMagnitude,
                                IN uint16_t lowFreqMagnitude,
                                IN int durationMilliseconds) { return false; }

        // public static methods (factories) -----------------------------------
        static smart_ptr<SourceDevice> create(IN IDirectInput8 * dinput,
                                IN const DIDEVICEINSTANCE& ddi);

private:
        // private typedefs ----------------------------------------------------
        typedef std::vector<pot_value_t> pot_vector_t;
        typedef std::vector<byte_t> byte_vector_t;

        // private helper methods ----------------------------------------------
        void initialize(IN IDirectInput8 * dinput,
                                IN const DIDEVICEINSTANCE& di);

        // private member data -------------------------------------------------
        COM_ptr<IDirectInputDevice8>    m_device;
        std::string                     m_name;
        std::string                     m_id;
        device_caps_t                   m_dcaps;
        pot_vector_t                    m_pot;
        byte_vector_t                   m_button;
        byte_t *                        m_data; // raw gamepad data
};



DirectInputDevice::DirectInputDevice
(
void
)
throw()
{
        m_data = NULL;
}



DirectInputDevice::~DirectInputDevice(void) throw()
{
        if (m_data) {
                delete[] m_data;
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      DirectInputDevice -- gamepad::SourceDevice class interface methods
//
////////////////////////////////////////////////////////////////////////////////

eDeviceState
DirectInputDevice::getState
(
void
)
throw()
{
        return eDevice_Unknown;
}



void 
DirectInputDevice::poll
(
void
)
throw()
{
        ASSERT(m_device, "null");

        // get new data values
        HRESULT hr = m_device->Poll();
        DI_VERIFY(DI_OK == hr || DI_NOEFFECT == hr, hr,
            "Failed to poll device");
        hr = m_device->GetDeviceState(m_dcaps.dataBytes, m_data);
        DI_VERIFY(DI_OK == hr, hr,
            "Failed to get device state");

        // update potentiometers
        for (int i = 0; i < m_dcaps.nAxes; ++i) {
                m_pot[i].update(getAxisValue(m_data, m_dcaps, i));
        }

        // update buttons
        for (int i = 0; i < m_dcaps.nButtons; ++i) {
                // clear "was pushed" and "was released" bits
                m_button[i] &= ~eButtonWasPushed;
                m_button[i] &= ~eButtonWasReleased;

                dword_t dwValue = gamepad::getButtonValue(m_data, m_dcaps, i);
                m_button[i] = updateButton(m_button[i], dwValue != 0);
        }
}



const pot_value_t& 
DirectInputDevice::getPotValue
(
IN int potIndex
)
{
        ASSERT(potIndex >= 0 && potIndex < m_dcaps.nAxes,
            "Invalid potentiometer index: %d", potIndex);

        return m_pot[potIndex];
}



eButton 
DirectInputDevice::getButtonValue
(
IN int buttonIndex
)
{
        ASSERT(buttonIndex >= 0 && buttonIndex < m_dcaps.nButtons,
            "Bad button index: %d", buttonIndex);

        return (eButton) m_button[buttonIndex];
}



////////////////////////////////////////////////////////////////////////////////
//
//      DirectInputDevice -- public class methods
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<SourceDevice>
DirectInputDevice::create
(
IN IDirectInput8 * dinput,
IN const DIDEVICEINSTANCE& ddi
)
{
        ASSERT(dinput, "null");

        smart_ptr<DirectInputDevice> local = new DirectInputDevice;
        ASSERT(local, "out of memory");

        local->initialize(dinput, ddi);

        return local;
}




void
DirectInputDevice::initialize
(
IN IDirectInput8 * dinput,
IN const DIDEVICEINSTANCE& ddi
)
{
        ASSERT(dinput, "null");
        ASSERT(!m_device, "already have a direct input device?");

        LPUNKNOWN punkOuter = NULL;
        IDirectInputDevice8 * pdev = NULL;
        HRESULT hr = dinput->CreateDevice(ddi.guidInstance, &pdev, punkOuter);
        DI_VERIFY(S_OK == hr && pdev, hr,
             "Failed to create direct input device for gamepad");
        m_device = pdev;

        // save some fields
        m_name = ddi.tszInstanceName;
        m_name += ": ";
        m_name += ddi.tszProductName;

        const int bufsize = 64;
        char buffer[bufsize];
        m_id = getGuidString(ddi.guidInstance, buffer, bufsize);

        // create custom data format
        m_data = getDataFormatForDevice(m_device, m_dcaps);
        DPRINTF("Just created data format for new DirectInput device");
        DPRINTF("  nAxes = nPots = %d", m_dcaps.nAxes);
        DPRINTF("  nPOVs = %d", m_dcaps.nPOVs);
        DPRINTF("  nButtons = %d", m_dcaps.nButtons);
        DPRINTF("  data size = %d bytes", m_dcaps.dataBytes);

        // set the data format
        hr = m_device->SetDataFormat((LPCDIDATAFORMAT) m_data);
        DI_VERIFY(DI_OK == hr, hr, "Failed to set data format on new device");

        // acquire the device
        hr = m_device->Acquire();
        DI_VERIFY(DI_OK == hr || S_FALSE == hr, hr,
            "Failed to Acquire() new device");

        // set up pot + button arrays
        m_pot.resize(m_dcaps.nAxes);
        m_button.resize(m_dcaps.nButtons, eButtonUp);
}



////////////////////////////////////////////////////////////////////////////////
//
//      DirectInputFactory -- object that implements the SourceDeviceFactory
//              interface based on the Microsoft DirectInput APIs
//
////////////////////////////////////////////////////////////////////////////////

class DirectInputFactory : public SourceDeviceFactory {
public:
        // constructor, destructor ---------------------------------------------
        // public class methods ------------------------------------------------
        void initialize(void);

        // gamepad::SourceDeviceFactory class interface methods ----------------
        virtual const char * getName(void) const throw();
        virtual int getCount(void);
        virtual smart_ptr<SourceDevice> getSourceDevice(IN int index);

private:
        // private typedefs ----------------------------------------------------
        struct enum_device_context_t {
                // constructor, manipulators
                enum_device_context_t(void) throw() { this->clear(); }
                void clear(void) throw() {
                                pThis = NULL;
                        }

                // data fields
                DirectInputFactory *    pThis;
        };

        typedef std::map<std::string, smart_ptr<SourceDevice> > device_map_t;

        // private helper methods ----------------------------------------------
        void refreshDevices(void);
        static BOOL CALLBACK deviceCallback(LPCDIDEVICEINSTANCEA lpddi,
                                void * context);
        void addDevice(IN const DIDEVICEINSTANCEA& ddi);

        // private member data -------------------------------------------------
        COM_ptr<IDirectInput8>          m_dinput;
        device_map_t                    m_devices;
};



////////////////////////////////////////////////////////////////////////////////
//
//      DirectInputFactory -- public class methods
//
////////////////////////////////////////////////////////////////////////////////

void
DirectInputFactory::initialize
(
void
)
{
        DPRINTF("Creating a new DirectInput device factory...");

        ASSERT(!m_dinput, "already have a direct input object?");

        // create our DirectInput object
        HINSTANCE hinst = GetModuleHandle(NULL);
        dword_t dwVersion = DIRECTINPUT_VERSION;
        REFIID riid = IID_IDirectInput8;
        LPUNKNOWN punkOuter = NULL;
        HRESULT hr = DirectInput8Create(hinst, dwVersion, riid, m_dinput,
            punkOuter);
        DI_VERIFY(DI_OK == hr && m_dinput, hr,
            "Failed to create DirectInput object");
}



////////////////////////////////////////////////////////////////////////////////
//
//      DirectInputFactory -- gamepad::SourceDeviceFactory methods
//
////////////////////////////////////////////////////////////////////////////////

const char *
DirectInputFactory::getName
(
void
)
const
throw()
{
        return "DirectInput Factory";
}



int
DirectInputFactory::getCount
(
void
)
{
        perf::Timer timer("DirectInputFactory::getCount");
        this->refreshDevices();

        return m_devices.size();
}



smart_ptr<SourceDevice>
DirectInputFactory::getSourceDevice
(
IN int index
)
{
        ASSERT(index >= 0, "Bad device index: %d", index);

        if (index >= (int) m_devices.size()) {
                DPRINTF("Device %d is now detached (?)", index);
                return NULL;
        }

        device_map_t::iterator i = m_devices.begin();
        for (; index > 0; --index) {
                ++i;
        }

        return i->second;
}



////////////////////////////////////////////////////////////////////////////////
//
//      DirectInputFactory -- private helper methods
//
////////////////////////////////////////////////////////////////////////////////

void
DirectInputFactory::refreshDevices
(
void
)
{
        ASSERT(m_dinput, "null");

        // enumerate all gamepads
        dword_t dwDevType = DI8DEVCLASS_GAMECTRL;
        dword_t dwFlags = DIEDFL_ALLDEVICES;
        enum_device_context_t edc;
        edc.pThis = this;
        HRESULT hr = m_dinput->EnumDevices(dwDevType, deviceCallback, &edc,
            dwFlags);
        DI_VERIFY(DI_OK == hr, hr, "Failed to enumerate DirectInput devices");
}



BOOL CALLBACK
DirectInputFactory::deviceCallback
(
LPCDIDEVICEINSTANCEA lpddi,
void * context
)
{
        ASSERT(lpddi, "null device instance?");
        enum_device_context_t * pedc = (enum_device_context_t *) context;
        ASSERT(pedc, "null context");
        ASSERT(pedc->pThis, "null");

        pedc->pThis->addDevice(*lpddi);

        return DIENUM_CONTINUE;
}



void
DirectInputFactory::addDevice
(
IN const DIDEVICEINSTANCEA& ddi
)
{
        const int bufsize = 64;
        char guid[bufsize];
        getGuidString(ddi.guidInstance, guid, bufsize);
//      DPRINTF("Checking device: %s", guid);

        // already have this device?
        if (m_devices.end() != m_devices.find(guid)) {
                // already have it!
                return;
        }

        // this is a device we haven't seen before
        DPRINTF("New direct input device: %s", guid);
        smart_ptr<SourceDevice> device =
            DirectInputDevice::create(m_dinput, ddi);
        ASSERT(device, "null");

        // add to map
        m_devices[guid] = device;
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<SourceDeviceFactory>
getDirectInputSourceDeviceFactory
(
void
)
{
        smart_ptr<DirectInputFactory> local = new DirectInputFactory;
        ASSERT(local, "out of memory");

        local->initialize();

        return local;
}



};      // gamepad namespace