Joystick.cpp

Go to the documentation of this file.

#include "Joystick.h"

namespace Devices
{
        //-----------------------------------------------------------------------------
        // Name: EnumJoysticksCallback()
        // Desc: Called once for each enumerated joystick. If we find one, create a
        //       device interface on it so we can play with it.
        //-----------------------------------------------------------------------------
        BOOL CALLBACK Joystick::EnumJoysticksCallback(const DIDEVICEINSTANCE* pdidInstance, VOID* pContext)
        {
                Joystick* joystick = static_cast<Joystick*>(pContext);

                char msg[199];
                sprintf_s(msg, 199, "Joystick::EnumJoysticksCallback {%08lX-%04hX-%04hX-%02hhX%02hhX-%02hhX%02hhX%02hhX%02hhX%02hhX%02hhX}",
                          pdidInstance->guidInstance.Data1, pdidInstance->guidInstance.Data2, pdidInstance->guidInstance.Data3,
                          pdidInstance->guidInstance.Data4[0], pdidInstance->guidInstance.Data4[1], pdidInstance->guidInstance.Data4[2], pdidInstance->guidInstance.Data4[3],
                          pdidInstance->guidInstance.Data4[4], pdidInstance->guidInstance.Data4[5], pdidInstance->guidInstance.Data4[6], pdidInstance->guidInstance.Data4[7]);
                joystick->logger->Log(msg);

                if (joystick->config->serialno == GUID_NULL)
                        joystick->config->serialno = pdidInstance->guidInstance;

                joystick->guids.push_back(pdidInstance->guidInstance);

                return DIENUM_CONTINUE;
        }

        //-----------------------------------------------------------------------------
        // Name: EnumObjectsCallback()
        // Desc: Callback function for enumerating objects (axes, buttons, POVs) on a 
        //       joystick. This function enables user interface elements for objects
        //       that are found to exist, and scales axes min/max values.
        //-----------------------------------------------------------------------------
        BOOL CALLBACK Joystick::EnumObjectsCallback(const DIDEVICEOBJECTINSTANCE* pdidoi, VOID* pContext)
        {
                Joystick* joystick = static_cast<Joystick*>(pContext);

                HRESULT hr;

                //static int nSliderCount = 0;  // Number of returned slider controls
                //static int nPOVCount = 0;     // Number of returned POV controls

                // For axes that are returned, set the DIPROP_RANGE property for the
                // enumerated axis in order to scale min/max values.
                if (pdidoi->dwType & DIDFT_AXIS)
                {
                        DIPROPRANGE diprg;
                        diprg.diph.dwSize = sizeof(DIPROPRANGE);
                        diprg.diph.dwHeaderSize = sizeof(DIPROPHEADER);
                        diprg.diph.dwHow = DIPH_BYID;
                        diprg.diph.dwObj = pdidoi->dwType; // Specify the enumerated axis
                        for (UINT i = 0; i < joystick->config->axes.size(); i++)
                        {
                                if ((joystick->config->axes[i].index == 0 && pdidoi->guidType == GUID_XAxis) ||
                                        (joystick->config->axes[i].index == 1 && pdidoi->guidType == GUID_YAxis) ||
                                        (joystick->config->axes[i].index == 2 && pdidoi->guidType == GUID_ZAxis) ||
                                        (joystick->config->axes[i].index == 3 && pdidoi->guidType == GUID_RxAxis) ||
                                        (joystick->config->axes[i].index == 4 && pdidoi->guidType == GUID_RyAxis) ||
                                        (joystick->config->axes[i].index == 5 && pdidoi->guidType == GUID_RzAxis))
                                {
                                        diprg.lMin = joystick->config->axes[i].min;
                                        diprg.lMax = joystick->config->axes[i].max;

                                        char msg[99];
                                        sprintf_s(msg, 99, "Joystick::EnumObjectsCallback Configured %S with range %i to %i", pdidoi->tszName, diprg.lMin, diprg.lMax);
                                        joystick->logger->Log(msg);

                                        // Set the range for the axis
                                        if (FAILED(hr = joystick->g_pJoystick->SetProperty(DIPROP_RANGE, &diprg.diph)))
                                        {
                                                joystick->logger->Log("Joystick::EnumObjectsCallback SetProperty failed!", Logger::Error, hr);
                                                return DIENUM_STOP;
                                        }
                                        else
                                        {
                                                return DIENUM_CONTINUE;
                                        }
                                }
                        }
                        char msg[99];
                        sprintf_s(msg, 99, "Joystick::EnumObjectsCallback Unused %S", pdidoi->tszName);
                        joystick->logger->Log(msg);
                }

                return DIENUM_CONTINUE;
        }

        void Joystick::Initialize(Logger* prmLogger, JoystickConfig* prmConfig, Bus* prmBus, LPDIRECTINPUT8 g_pDI)
        {
                logger = prmLogger;
                config = prmConfig;
                bus = prmBus;

                HRESULT hr;

                logger->Log("Joystick::Initialize Calling EnumDevices...", Logger::Info);
                if (FAILED(hr = g_pDI->EnumDevices(DI8DEVCLASS_GAMECTRL, EnumJoysticksCallback, this, DIEDFL_ATTACHEDONLY)))
                {
                        logger->Log("Joystick::Initialize EnumDevices failed!", Logger::Error, hr);
                        config->enable = false;
                        return;
                }

                bool found = false;
                for (UINT i = 0; i < guids.size(); i++)
                {
                        if (guids.at(i) == config->serialno)
                        {
                                found = true;
                                break;
                        }
                }
                if (!found)
                {
                        logger->Log("Joystick::Initialize Could not find in list of enumerated GUIDs!", Logger::Error);
                        config->enable = false;
                        return;
                }

                // Obtain an interface to the enumerated joystick.
                if (FAILED(hr = g_pDI->CreateDevice(config->serialno, &g_pJoystick, NULL)))
                {
                        logger->Log("Joystick::Initialize CreateDevice failed!", Logger::Error, hr);
                        config->enable = false;
                        return;
                }

                // Set the data format to "simple joystick" - a predefined data format 
                // A data format specifies which controls on a device we are interested in,
                // and how they should be reported. This tells DInput that we will be
                // passing a DIJOYSTATE structure to IDirectInputDevice::GetDeviceState().
                if (FAILED(hr = g_pJoystick->SetDataFormat(&c_dfDIJoystick)))
                {
                        logger->Log("Joystick::SetDataFormat failed!", Logger::Error, hr);
                        config->enable = false;
                        return;
                }

                // Set the cooperative level to let DInput know how this device should
                // interact with the system and with other DInput applications.
                if (FAILED(hr = g_pJoystick->SetCooperativeLevel(NULL, DISCL_NONEXCLUSIVE | DISCL_BACKGROUND)))
                {
                        logger->Log("Joystick::SetCooperativeLevel failed!", Logger::Error, hr);
                        config->enable = false;
                        return;
                }

                char msg[199];
                sprintf_s(msg, 199, "Joystick::EnumObjectsCallback {%08lX-%04hX-%04hX-%02hhX%02hhX-%02hhX%02hhX%02hhX%02hhX%02hhX%02hhX}",
                          config->serialno.Data1, config->serialno.Data2, config->serialno.Data3,
                          config->serialno.Data4[0], config->serialno.Data4[1], config->serialno.Data4[2], config->serialno.Data4[3],
                          config->serialno.Data4[4], config->serialno.Data4[5], config->serialno.Data4[6], config->serialno.Data4[7]);
                logger->Log(msg);

                // Enumerate the joystick objects. The callback function enabled user
                // interface elements for objects that are found, and sets the min/max
                // values property for discovered axes.
                if (FAILED(hr = g_pJoystick->EnumObjects(EnumObjectsCallback, this, DIDFT_ALL)))
                {
                        logger->Log("Joystick::EnumObjects failed!", Logger::Error, hr);
                        config->enable = false;
                        return;
                }

                axes.resize(7); // x y z rx ry rz slider0 slider1

                RtlZeroMemory(&jsOld, sizeof(DIJOYSTATE));
        }

        void Joystick::Destroy()
        {
                if (g_pJoystick)
                        g_pJoystick->Unacquire();

                // Release any DirectInput objects.
                SAFE_RELEASE(g_pJoystick);
        }

        void Joystick::FrameMove(float fElapsed)
        {
                acquired = false;

                if (!config->enable)
                        return;

                if (g_pJoystick == nullptr)
                        return;

                HRESULT hr;

                DIJOYSTATE js;

                // Poll the device to read the current state
                if (FAILED(hr = g_pJoystick->Poll()))
                {
                        //logger->Log("Joystick::FrameMove Poll failed!", Logger::Warn, hr);

                        // DInput is telling us that the input stream has been
                        // interrupted. We aren't tracking any state between polls, so
                        // we don't have any special reset that needs to be done. We
                        // just re-acquire and try again.
                        if (FAILED(hr = g_pJoystick->Acquire()))
                        {
                                //logger->Log("Joystick::FrameMove Acquire failed!", Logger::Warn, hr);
                        }

                        // hr may be DIERR_OTHERAPPHASPRIO or other errors.  This
                        // may occur when the app is minimized or in the process of 
                        // switching, so just try again later 
                        return;
                }

                // Get the input's device state
                if (FAILED(hr = g_pJoystick->GetDeviceState(sizeof(DIJOYSTATE), &js)))
                {
                        logger->Log("Joystick::FrameMove GetDeviceState failed!", Logger::Warn, hr);
                        return;
                }

                acquired = true;

                for (UINT i = 0; i < config->axes.size(); i++)
                {
                        switch (config->axes.at(i).index)
                        {
                        case 0: axes.at(0) = static_cast<float>(js.lX);
                                break;
                        case 1: axes.at(1) = static_cast<float>(js.lY);
                                break;
                        case 2: axes.at(2) = static_cast<float>(js.lZ);
                                break;
                        case 3: axes.at(3) = static_cast<float>(js.lRx);
                                break;
                        case 4: axes.at(4) = static_cast<float>(js.lRy);
                                break;
                        case 5: axes.at(5) = static_cast<float>(js.lRz);
                                break;
                        case 6: axes.at(6) = static_cast<float>(js.rglSlider[0]);
                                break;
                        case 7: axes.at(7) = static_cast<float>(js.rglSlider[1]);
                                break;
                        }

                        if (fabsf(axes.at(config->axes.at(i).index)) < config->axes.at(i).deadband)
                                axes.at(config->axes.at(i).index) = 0.0f;

                        axes.at(config->axes.at(i).index) *= config->axes.at(i).scale;

                        if (config->axes.at(i).inverse)
                                axes.at(config->axes.at(i).index) = 1.0f - axes.at(config->axes.at(i).index);
                }

                for (UINT j = 0; j < config->buttons.size(); j++)
                {
                        Devices::JoystickConfig::Button* button = &config->buttons.at(j);
                        if (button->onPress == (js.rgbButtons[button->index] > 0))
                        {
                                button->durationElapsed += fElapsed;
                                if ((button->durationRequired == 0.0f && js.rgbButtons[button->index] != jsOld.rgbButtons[button->index]) ||
                                        (button->durationRequired != 0.0f && button->durationElapsed >= button->durationRequired && !button->durationTripped))
                                {
                                        button->durationTripped = true;
                                        bus->AppendCommands(&button->commands);
                                        char msg[99];
                                        sprintf_s(msg, 99, "Joystick::FrameMove location %i button %i state %i elapsed %.1f", config->location, button->index, js.rgbButtons[button->index], button->durationElapsed);
                                        logger->Log(msg, Logger::Level::Info);
                                }
                        }
                        else
                        {
                                button->durationElapsed = 0.0f;
                                button->durationTripped = false;
                        }
                }

                jsOld = js;
        }

        bool Joystick::IsActive() const
        {
                return acquired;
        }

        float Joystick::GetAxis(UINT axis)
        {
                assert(axis < axes.size());
                return axes.at(axis);
        }

        bool Joystick::GetButton(int button) const
        {
                assert(button >= 0 && button < 32);
                return jsOld.rgbButtons[button] > 0;
        }

        DWORD Joystick::GetPOV(int pov)
        {
                assert(pov >= 0 && pov < 4);
                return jsOld.rgdwPOV[pov];
        }
}