direct-input/test/raw.cpp

Go to the documentation of this file.

/*
 * raw.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Performs raw lookups and reads of DirectInput devices.
 */

// includes --------------------------------------------------------------------
#include <iostream>
#include <time.h>

#include "common/common.h"
#include "direct-input/di-diagnostics.h"
#include "perf/perf.h"
#include "util/file.h"
#include "wave-windows/wave-windows.h"


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

static BOOL
deviceCallback
(
LPCDIDEVICEINSTANCEA lpddi,
void * context
)
{
        ASSERT(lpddi, "null device instance?");
        // ASSERT(context) -- we don't care

        std::cerr << "Device found:\n";
        std::cerr << *lpddi;

        if (context) {
                GUID * pg = (GUID *) context;
                *pg = lpddi->guidInstance;
                return FALSE;
        }
        return TRUE;
}



#define DUMP_FORMAT( token )                                            \
        {                                                               \
                DPRINTF("Dumping %s...", #token);                       \
                std::cerr << ( token );                                 \
        }


static void
doTest
(
void
)
{
        // create DirectInput object
        HINSTANCE hinst = GetModuleHandle(NULL);
        ASSERT_THROW(hinst, "failed to acquire win32 instance handle");
        DWORD dwVersion = DIRECTINPUT_VERSION;
        REFIID riid = IID_IDirectInput8;
        LPUNKNOWN punkOuter = NULL;
        COM_ptr<IDirectInput8> pdi;
        ASSERT(!pdi, "should be null");

        HRESULT hr = DirectInput8Create(hinst, dwVersion, riid,
            pdi, punkOuter);
        DI_VERIFY(DI_OK == hr && pdi, hr,
            "Failed to create DirectInput object");

        // enumerate all devices
        DWORD dwDevType = DI8DEVCLASS_ALL;
        void * context = NULL;
        DWORD dwFlags = DIEDFL_ALLDEVICES;
        LPDIENUMDEVICESCALLBACKA callback =
            (LPDIENUMDEVICESCALLBACKA) deviceCallback;

        DPRINTF("ALL DEVICES =============");
        hr = pdi->EnumDevices(dwDevType, callback, context, dwFlags);
        DI_VERIFY(DI_OK == hr, hr,
            "Failed to enumerate direct input devices");

        // enumerate only gamepads
        DPRINTF("GAMEPADS =============");
        dwDevType = DI8DEVCLASS_GAMECTRL;
        hr = pdi->EnumDevices(dwDevType, callback, context, dwFlags);
        DI_VERIFY(DI_OK == hr, hr,
            "Failed to enumerate direct input gamepad devices");

        // final pass: pick first one
        DPRINTF("PICKING FIRST GAMEPAD ============");
        GUID guidGamepad;
        context = (void *) &guidGamepad;
        hr = pdi->EnumDevices(dwDevType, callback, context, dwFlags);
        DI_VERIFY(DI_OK == hr, hr,
            "Failed to enumerate gamepad devices");
        std::cerr << "Picked gamepad: " << guidGamepad << "\n";

        // now create a device for this gamepad
        IDirectInputDevice8 * pdiDevice = NULL;
        hr = pdi->CreateDevice(guidGamepad, &pdiDevice, punkOuter);
        DI_VERIFY(DI_OK == hr && pdiDevice, hr,
            "Failed to create device for first gamepad");

        // dump the various DirectInput data formats
//      DUMP_FORMAT(c_dfDIMouse)
//      DUMP_FORMAT(c_dfDIMouse2)
//      DUMP_FORMAT(c_dfDIKeyboard)
//      DUMP_FORMAT(c_dfDIJoystick)
//      DUMP_FORMAT(c_dfDIJoystick2)

/*
        // based on inspection, Joystick2 seems to be the most advanced
        // (we need lots of inputs to handle gamepads)
        hr = pdiDevice->SetDataFormat(&c_dfDIJoystick2);
        DI_VERIFY(DI_OK == hr, hr,
            "Failed to set data format");

        // acquire
        hr = pdiDevice->Acquire();
        DI_VERIFY(DI_OK == hr || S_FALSE == hr, hr,
            "Failed to acquire gamepad");
*/
        // interrogate the gamepad
//      DIDEVCAPS devcaps;
//      devcaps.dwSize = sizeof(DIDEVCAPS);     // have to set this one field
//      hr = pdiDevice->GetCapabilities(&devcaps);
//      DI_VERIFY(DI_OK == hr, hr,
//          "Failed to get device capabilities");
//      std::cerr << devcaps;
//      ASSERT(false, "halt");

        // now we'll grab current data using Joystick2 format
//      DIJOYSTATE2 joy2;
//      dword_t dwSize = sizeof(DIJOYSTATE2);
//      hr = pdiDevice->GetDeviceState(dwSize, &joy2);
//      DI_VERIFY(DI_OK == hr, hr,
//          "Failed to get device state");

        // given the data format and data, dump the results
//      DPRINTF("About to dump raw data from device...");
//      gamepad::writeStateDebug(std::cerr, c_dfDIJoystick2, (byte_t *) &joy2);
//      gamepad::writeState(std::cerr, c_dfDIJoystick2, (byte_t *) &joy2);

        // now build our own custom data format from the device capabilities
        gamepad::device_caps_t dc;
        byte_t * pDataFormat = gamepad::getDataFormatForDevice(pdiDevice, dc);
        ASSERT_THROW(pDataFormat, "Failed to construct data format");
        DIDATAFORMAT * pdf = (DIDATAFORMAT *) pDataFormat;
        DUMP_FORMAT(*pdf);
        dc.dump("Detected capabilities for first gamepad");

        // now set our custom data format
        hr = pdiDevice->SetDataFormat(pdf);
        DI_VERIFY(DI_OK == hr, hr,
            "Failed to set custom data format");

        // acquire
        hr = pdiDevice->Acquire();
        DI_VERIFY(DI_OK == hr || S_FALSE == hr, hr,
            "Failed to acquire gamepad");

        // get buffer to hold state
        ASSERT_THROW(dc.dataBytes > 0, "Bad data bytes: " << dc.dataBytes);
        byte_t * state = new byte_t[dc.dataBytes];
        ASSERT(state, "out of memory");

        // now loop
        const int desiredHz = 33;       // run loop at this many cycles/second
        const int msSleep = 1000 / desiredHz;
        const int nObjs = 10;   // show this many objects
        while (true) {
                Sleep(msSleep);
                hr = pdiDevice->Poll();
                DI_VERIFY(DI_OK == hr || DI_NOEFFECT == hr, hr,
                    "Failed to poll device");
                hr = pdiDevice->GetDeviceState(dc.dataBytes, state);
                DI_VERIFY(DI_OK == hr, hr,
                    "Failed to get device state");

                long * pl = (long *) state;
                for (int i = 0; i < nObjs; ++i, ++pl) {
                        fprintf(stderr, " %6d", *pl);
                }
                fprintf(stderr, "\n");
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      entry point
//
////////////////////////////////////////////////////////////////////////////////

int
main
(
IN int argc,
IN const char * argv[]
)
{

        int retval = 0;
        try {
                perf::Timer timer("overall timer");

                doTest();

        } catch (std::exception& e) {
                DPRINTF("EXCEPTION: %s", e.what());
                retval = 1;
        }

        perf::dumpTimingSummary(std::cerr);

        return retval;
}