main.cpp

Go to the documentation of this file.

/*
 * main.cpp
 *
 * Copyright (C) 2009,2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Sample gamepad configurator.
 */

// include files ---------------------------------------------------------------
#include <iostream>
#include <stdio.h>

#include "gamepad-config/gamepad-config.h"
#include "i18n/i18n.h"
#include "perf/perf.h"
#include "threadsafe/threadsafe.h"
#include "threadsafe/threadsafe_multimap.h"


// if all else fails fall back to US English
static const char * s_defaultLocale             = "en_US.UTF-8";


// I use this because it has a nicer interface than std::multimap<>
typedef threadsafe_multimap<std::string, int> string_int_map_t;


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

static int
selectFromMap
(
IN string_int_map_t& map,
IN const char * title
)
{
        ASSERT(title, "null");

        int N = map.size();
        ASSERT(N > 0, "Empty map?");
        fprintf(stdout, "\n%s\n", title);

        // walk through and display options (alphabetic order)
        int ctr = 0;
        string_int_map_t::iterator_t i;
        map.getIterator(i);
        std::string name;
        int idx;
        while (map.getNextElement(i, name, idx)) {
                ++ctr;
                fprintf(stdout, "  %2d...%s\n", ctr, name.c_str());
        }

        // have user pick one
        int iSelected = 1;
        if (N > 1) {
                iSelected = 0;
                while (iSelected < 1 || iSelected > N) {
                        fprintf(stdout,
                            "Please enter your selection [1-%d]: ", N);
                        const int bufsize = 16;
                        char buffer[bufsize];

                        fgets(buffer, bufsize, stdin);
                        iSelected = atoi(buffer);
                }
        }

        // get index of selection
        map.getIterator(i);
        while (iSelected && map.getNextElement(i, name, idx)) {
                --iSelected;
        }
        ASSERT(!iSelected, "map changed size?");
        DPRINTF("  Selected option %d --> index %d", iSelected, idx);
        return idx;
}



static smart_ptr<gamepad::SourceDevice>
selectDevice
(
IN gamepad::Manager * mgr
)
{
        ASSERT(mgr, "null");

        string_int_map_t map;

        int nDevs = mgr->getSourceDeviceCount();
        ASSERT_THROW(nDevs > 0,
            "No source devices found!  Is everything plugged in?");
        for (int i = 0; i < nDevs; ++i) {
                smart_ptr<gamepad::SourceDevice> device =
                    mgr->getSourceDevice(i);
                ASSERT_THROW(device, "manager returned null device for index: "
                    << i);
                std::string name = device->getPublicName();
        //      name += " (";
        //      name += device->getUniqueId();
        //      name += ")";
                map.insert(name, i);
        }
        int iSelected = selectFromMap(map, "What is the input source device?");
        ASSERT_THROW(iSelected >= 0 && iSelected < nDevs,
            "Invalid input device selection: " << iSelected);

        smart_ptr<gamepad::SourceDevice> device =
            mgr->getSourceDevice(iSelected);
        ASSERT_THROW(device, "manager returned null for selected device?");
        fprintf(stdout, "Selected input device '%s'\n",
            device->getPublicName());

        return device;
}



static smart_ptr<gamepad::Type>
selectType
(
IN gamepad::Manager * mgr
)
{
        ASSERT(mgr, "null");

        string_int_map_t map;
        int nTypes = mgr->getTypeCount();
        ASSERT_THROW(nTypes > 0, "No valid gamepad types found!");
        for (int i = 0; i < nTypes; ++i) {
                smart_ptr<gamepad::Type> type = mgr->getType(i);
                ASSERT_THROW(type, "manager returned null type for index: "
                    << i);
                const char * name = type->getName();
                map.insert(name, i);
        }
        int iSelected = selectFromMap(map,
            "What type of gamepad is being configured?");
        ASSERT_THROW(iSelected >= 0 && iSelected < nTypes,
            "Invalid gamepad type selection: " << iSelected);
        smart_ptr<gamepad::Type> type = mgr->getType(iSelected);
        ASSERT_THROW(type, "manager returned null for selected type?");
        fprintf(stdout, "Selected gamepad type '%s'\n", type->getName());

        return type;
}



static void
displayHints
(
IN i18n::Manager * mgr
)
{
        ASSERT(mgr, "null");

        const char * friendly = i18n::getString(mgr, "friendlyName");
        fprintf(stdout, "\nConfiguring gamepad: %s\n", friendly);

        const int bufsize = 16;
        char buffer[bufsize];
        for (int i = 1; ; ++i) {
                snprintf(buffer, bufsize, "hint%d", i);
                const char * hint = mgr->getString(buffer);
                if (!hint)
                        break;  // no more hints
                fprintf(stdout, "  %s\n", hint);
        }

        fprintf(stdout, "Press Enter when ready: ");
        fgets(buffer, bufsize, stdin);
}



static int
atExtreme
(
IN const gamepad::pot_value_t& pv
)
throw()
{
        if (!pv.isValid())
                return 0;       // not even valid--skip it

        int range = pv.maxSeen - pv.minSeen;
        ASSERT(range > 0, "supposed to be valid!");
        int threshold = (int) (0.2 * range) + 1;

        int dx = pv.value - pv.minSeen;
        if (dx <= threshold) {
                return -1;      // pot is near minimal value
        }
        dx = pv.maxSeen - pv.value;
        if (dx <= threshold) {
                return +1;      // pot is near maximal value
        }
        return 0;       // somewhere in the middle
}



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

int
main
(
IN int argc,
IN const char * argv[]
)
{
        int retval = 0;
        ASSERT(2 == argc, "Usage: configureGamepad <configDataDirectory>");
        const char * dataDir = argv[1];
        DPRINTF("Using data directory: %s", dataDir);

        try {
                perf::Timer timer("overall timer");

                // get data directory
                smart_ptr<nstream::Manager> fsMgr =
                    nstream::getFilesystemManager(dataDir);
                ASSERT_THROW(fsMgr,
                    "failed to create filesystem stream manager for path: " <<
                    dataDir);
                smart_ptr<nstream::Folder> root = fsMgr->getRoot();
                ASSERT(root, "null");

                // start up manager
                fprintf(stdout, "Initializing gamepad manager...\n");
                smart_ptr<gamepad::Manager> mgr =
                    gamepad::Manager::create(root);
                ASSERT_THROW(mgr, "failed to create gamepad manager");
                fprintf(stdout, "Discovering devices...\n");
                mgr->rediscover();

                // let user select source device
                smart_ptr<gamepad::SourceDevice> device = selectDevice(mgr);
                ASSERT_THROW(device, "no gamepad input device selected");

                // let user select a gamepad type
                smart_ptr<gamepad::Type> type = selectType(mgr);
                ASSERT_THROW(type, "no gamepad type selected");

                const char * name = "Test Gamepad Mapping";

                // get localization manager for instructions
                const char * locale = i18n::getHostLocale();
                smart_ptr<i18n::Manager> configMgr =
                    gamepad::getConfigLocaleMgr(locale, s_defaultLocale,
                        root);
                ASSERT_THROW(configMgr, "failed to create locale mgr");
                DPRINTF("Using strings for locale: '%s'",
                    configMgr->getLocale());

                const char * endCalibrate =
                    getString(configMgr, "endCalibrate");

                // get localization manager for gamepad type
                smart_ptr<i18n::Manager> gamepadMgr =
                    gamepad::getTypeLocaleMgr(type, locale, s_defaultLocale,
                        root);
                ASSERT_THROW(gamepadMgr,
                    "failed to create locale manager for gamepad type");
                const char * pressMainButton =
                    getString(gamepadMgr, "pressMainAction");

                displayHints(gamepadMgr);

                // create configurator
                smart_ptr<gamepad::Configurator> config =
                    gamepad::Configurator::create(mgr, device, type, name);
                ASSERT_THROW(config, "failed to create gamepad configurator");

                // loop and call configurator...
                const int s_hz = 100;   // sample s_hz times per second
                fprintf(stdout, "\nConfiguring gamepad (sampling at %d hz)\n",
                    s_hz);
                ASSERT_THROW(s_hz > 0, "Bad sample rate: " << s_hz);
                int msSleep = 1000 / s_hz;
                int currStep = -1;
                gamepad::config_status_t status;
                std::string friendlyInstruction;
                int counter = 0;
                const int displayFriendly = s_hz / 5;
                int waitCount = 0;      // number of cycles to wait
                const int calibrateCount = 8 * s_hz;
                const int endCalibrateCount = 3 * s_hz;
                while (true) {
                        mgr->update();
                        if (!config->update(status))
                                break;

                        sleepMilliseconds(msSleep);

                        ++counter;
                        if (counter >= displayFriendly) {
                                counter = 0;
                                fprintf(stdout, "%s",
                                    friendlyInstruction.c_str());
                                if (gamepad::eInstruction_ExternalEvent & status.instruct) {
                                        waitCount -= displayFriendly;
                                        float secRemaining;
                                        if (waitCount >= 0) {
                                                secRemaining = waitCount / (1.0 * s_hz);
                                        } else {
                                                secRemaining = (endCalibrateCount + waitCount) / (1.0 * s_hz);
                                        }
                                        fprintf(stdout,
                                            "  %3.1f seconds remaining...",
                                            secRemaining);
                                        if (waitCount < 1) {
                                                friendlyInstruction = endCalibrate;
                                        } if (waitCount < -endCalibrateCount) {
                                                config->calibrationComplete();
                                        }
                                }
                                fprintf(stdout, "\n");
                        }

                        if (currStep != status.currStep) {
                        //      fprintf(stdout, "\nNew step: %d of %d\n",
                        //          status.currStep + 1, status.maxSteps);
                        //      fprintf(stdout, "  instruction: %d\n",
                        //          status.instruct);
                                const char * token = 
                                    gamepad::getInstructionToken(status.instruct);
                        //      fprintf(stdout, "  token: '%s'\n", token);
                                const char * friendly =
                                    getString(configMgr, token);
                        //      fprintf(stdout, "  friendly: '%s'\n", friendly);
                        //      fprintf(stdout, "  current: %s\n",
                        //          status.logical);
                                const char * localName =
                                    getString(gamepadMgr, status.logical);
                        //      fprintf(stdout, "  local: '%s'\n", localName);
                        //      fprintf(stdout, "  primary button: %s\n",
                        //          status.primary);
                                currStep = status.currStep;

                                friendlyInstruction = "";
                                if (gamepad::eInstruction_RequestControl & status.instruct) {
                                        friendlyInstruction = localName;
                                        friendlyInstruction += " : ";
                                }
                                friendlyInstruction += friendly;
                                if (gamepad::eInstruction_PressMainAction & status.instruct) {
                                        friendlyInstruction += " ";
                                        friendlyInstruction += pressMainButton;
                                }
                                if (gamepad::eInstruction_ExternalEvent & status.instruct) {
                                        waitCount = calibrateCount;
                                }
                        }
                }

                smart_ptr<gamepad::Map> map = config->getMapping();
                ASSERT(map, "null");

                // okay, have a map based on user's configuration!
                // create a gamepad using that mapping
                smart_ptr<gamepad::Gamepad> gamepad;
                gamepad::Manager::eResult res =
                    mgr->createGamepad(device, map, gamepad);
                ASSERT_THROW(gamepad::Manager::eResult_Success == res,
                    "Failed to create gamepad.  result: " << res);
                ASSERT(gamepad, "null");

                // let the user know...
                const int bufsize = 16;
                char buffer[bufsize];
                fprintf(stdout, "\nSuccessfully created gamepad mapping!\n");
                fprintf(stdout, "Press <Enter> to test mapping with gamepad: ");
                fgets(buffer, bufsize, stdin);

                while (true) {
                        sleepMilliseconds(msSleep);

                        mgr->update();

                        if (gamepad::eDevice_Detached == gamepad->getState()) {
                                DPRINTF("Gamepad detached: halting!\n");
                                break;
                        }

                        const gamepad::Type * type = gamepad->getType();
                        ASSERT(type, "null");

                        gamepad::buttons_t buttons = gamepad->getButtons();
                        int mask = 1;
                        int nButtons = type->getInputCount(gamepad::eInput_Button);
                        for (int i = 0; i < nButtons; ++i) {
                                if (mask & buttons) {
                                        //DPRINTF("Button %d is pushed!", i);
                                        const char * logical =
                                            type->getLogicalName(gamepad::eInput_Button, i);
                                        const char * localName =
                                            getString(gamepadMgr, logical);
                                        gamepad::eButton btn = gamepad->getButton(i);
                                        std::string out;
                                        if (gamepad::eButtonDown & btn) {
                                                out += "isDown ";
                                        }
                                        if (gamepad::eButtonWasPushed & btn) {
                                                out += "wasPushed ";
                                        }
                                        if (gamepad::eButtonWasReleased & btn) {
                                                out += "wasReleased ";
                                        }
                                        printf("Button %d = %s = '%s': %s\n",
                                            i, logical, localName, out.c_str());
                                }
                                mask *= 2;
                        }

                        int nDpads = type->getInputCount(gamepad::eInput_Dpad);
                        for (int i = 0; i < nDpads; ++i) {
                                gamepad::eDpad dpad = gamepad->getDpad(i);
                                if (dpad) {
                                        const char * logical =
                                            type->getLogicalName(gamepad::eInput_Dpad, i);
                                        const char * localName =
                                            getString(gamepadMgr, logical);
                                        std::string out;
                                        if (gamepad::eDpad_Up & dpad) {
                                                out += "up ";
                                        }
                                        if (gamepad::eDpad_Down & dpad) {
                                                out += "down ";
                                        }
                                        if (gamepad::eDpad_Left & dpad) {
                                                out += "left ";
                                        }
                                        if (gamepad::eDpad_Right & dpad) {
                                                out += "right ";
                                        }
                                        printf("dpad %d = %s = '%s': %s\n", i,
                                            logical, localName, out.c_str());
                                }
                        }

                        int nJoys = type->getInputCount(gamepad::eInput_Joystick);
                        for (int i = 0; i < nJoys; ++i) {
                                gamepad::joystick_t joy;
                                gamepad->getJoystick(i, joy);

                                int x = atExtreme(joy.x);
                                int y = atExtreme(joy.y);
                                if (x || y) {
                                        const int bufsize = 256;
                                        char buffer[bufsize];
                                        const char * logical =
                                            type->getLogicalName(gamepad::eInput_Joystick, i);
                                        const char * localName =
                                            getString(gamepadMgr, logical);

                                        std::string out;
                                        if (x) {
                                                snprintf(buffer, bufsize,
                                                    "X:%d [%d, %d]", joy.x.value,
                                                    joy.x.minSeen, joy.x.maxSeen);
                                                out += buffer;
                                                out += "  ";
                                        }
                                        if (y) {
                                                snprintf(buffer, bufsize,
                                                    "Y:%d [%d, %d]", joy.y.value,
                                                    joy.y.minSeen, joy.y.maxSeen);
                                                out += buffer;
                                        }
                                        printf("joystick %d = %s = '%s': %s\n", i,
                                            logical, localName, out.c_str());
                                            
                                }
                        }

                        int nPots = type->getInputCount(gamepad::eInput_Pot);
                        for (int i = 0; i < nPots; ++i) {
                                gamepad::pot_value_t pv;
                                gamepad->getPot(i, pv);

                                int range = pv.maxSeen - pv.minSeen;
                                if (range < 0)
                                        continue;       // skip this
                                int threshold = (int) (0.1 * range) + 1;
                                if (pv.value >= threshold) {
                                        const char * logical =
                                            type->getLogicalName(gamepad::eInput_Pot, i);
                                        const char * localName =
                                            getString(gamepadMgr, logical);
                                        printf("pot %d = %s = '%s': %d range=[%d, %d]\n",
                                            i, logical, localName, pv.value,
                                            pv.minSeen, pv.maxSeen);
                                }
                        }
                }

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

        perf::dumpTimingSummary(std::cerr);
        return retval;
}