gamepad-map.cpp

Go to the documentation of this file.

/*
 * gamepad-map.cpp
 *
 * Copyright (C) 2009,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.
 *
 *
 * Gamepad mapping routines.
 */

// includes --------------------------------------------------------------------
#include "gamepad-map.h"                // always include our own header first

#include "datahash/datahash_util.h"
#include "util/parsing.h"


namespace gamepad {

// interface destructors
Map::~Map(void) throw() { }


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

////////////////////////////////////////////////////////////////////////////////
//
//      Mapping - class that implements the gamepad::Map interface
//
////////////////////////////////////////////////////////////////////////////////

class Mapping : public Map {
public:
        // constructor, destructor ---------------------------------------------
        ~Mapping(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN const Datahash * hash);

        // gamepad::Map class interface methods --------------------------------
        const char * getId(void) const throw() { return m_id.c_str(); }
        const char * getTypeId(void) const throw() { return m_typeId.c_str(); }
        const char * getName(void) const throw() { return m_name.c_str(); }
        const VecString& getDeviceNames(void) const throw() { return m_devices; }
        const button_map_t * getButtonMapping(IN const char * logicalName) const throw();
        const joystick_map_t * getJoystickMapping(IN const char * logicalName) const throw();
        const pot_map_t * getPotMapping(IN const char * logicalName) const throw();
        const dpad_map_t * getDpadMapping(IN const char * logicalName) const throw();

private:
        // private helper methods ----------------------------------------------
        typedef std::map<std::string, button_map_t> buttons_t;
        typedef std::map<std::string, joystick_map_t> joysticks_t;
        typedef std::map<std::string, pot_map_t> pots_t;
        typedef std::map<std::string, dpad_map_t> dpads_t;

        // private member data -------------------------------------------------
        std::string             m_id;
        std::string             m_typeId;
        std::string             m_name;
        VecString               m_devices;
        buttons_t               m_buttons;
        joysticks_t             m_joysticks;
        pots_t                  m_pots;
        dpads_t                 m_dpads;
};



void
Mapping::initialize
(
IN const Datahash * in_hash
)
{
        ASSERT(in_hash, "null");

        //DPRINTF("Reading gamepad mapping...");

        // get the "map" subhash
        const Datahash * hash = getSubhash(in_hash, "map");
        ASSERT_THROW(hash, "gamepad map hash does not contain 'map' section?");

        m_id = getString(hash, "id");
        //DPRINTF("  id: '%s'", m_id.c_str());
        m_typeId = getString(hash, "typeId");
        //DPRINTF("  type id: '%s'", m_typeId.c_str());
        m_name = getString(hash, "name");
        //DPRINTF("  name: %s", m_name.c_str());

        // get the list of device names supported (can be empty!)
        m_devices.clear();
        Datahash::iterator_t i;
        hash->getIterator("deviceName", i);
        while (const hash_value_t * phv = hash->getNextElementUnsafe(i)) {
                if (eHashDataType_String != phv->type)
                        continue;
                m_devices.push_back(phv->text);
        }
        //DPRINTF("  Mapping supports %d known devices", (int) m_devices.size());

        // read all buttons
        hash->getIterator("button", i);
        while (const hash_value_t * phv = hash->getNextElementUnsafe(i)) {
                if (eHashDataType_Hash != phv->type)
                        continue;       // skip

                const Datahash * btn = phv->hash;
                ASSERT(btn, "null hash in vector?");

                button_map_t bmap;
                const char * logical = getString(btn, "logical");
                const char * index = getString(btn, "button");
                bmap.index = atoi(index);
                //bmap.dump(logical);
                ASSERT_THROW(bmap.isValid(),
                    "Gamepad mapping for '" << logical << "' is not valid");
                m_buttons[logical] = bmap;
        }
        //DPRINTF("  Read %d button mappings", (int) m_buttons.size());

        // read all joysticks
        hash->getIterator("joystick", i);
        while (const hash_value_t * phv = hash->getNextElementUnsafe(i)) {
                if (eHashDataType_Hash != phv->type)
                        continue;
                const Datahash * joy = phv->hash;
                ASSERT(joy, "null hash in vector?");

                joystick_map_t jmap;
                const char * logical = getString(joy, "logical");
                jmap.xIndex = getInt(joy, "xAxis");
                jmap.yIndex = getInt(joy, "yAxis");

                //jmap.dump(logical);
                ASSERT_THROW(jmap.isValid(),
                    "Gamepad mapping for '" << logical << "' is not valid");
                m_joysticks[logical] = jmap;
        }
        //DPRINTF("  Read %d joystick mappings", (int) m_joysticks.size());

        // read all potentiometers
        hash->getIterator("pot", i);
        while (const hash_value_t * phv = hash->getNextElementUnsafe(i)) {
                if (eHashDataType_Hash != phv->type)
                        continue;
                const Datahash * pot = phv->hash;
                ASSERT(pot, "null hash in vector?");

                pot_map_t pmap;
                const char * logical = getString(pot, "logical");
                pmap.index = getInt(pot, "index");

                //pmap.dump(logical);
                ASSERT_THROW(pmap.isValid(),
                    "Gamepad mapping for '" << logical << "' is not valid");
                m_pots[logical] = pmap;
        }
        //DPRINTF("  Read %d potentiometer mappings", (int) m_pots.size());

        // read all directional pads (dpads)
        hash->getIterator("dpad", i);
        while (const hash_value_t * phv = hash->getNextElementUnsafe(i)) {
                if (eHashDataType_Hash != phv->type)
                        continue;
                const Datahash * dpad = phv->hash;
                ASSERT(dpad, "null hash in vector?");

                dpad_map_t dmap;
                const char * logical = getString(dpad, "logical");
                const char * type = getString(dpad, "type");
                if (!strcmp("pot", type)) {
                } else if (!strcmp("button", type)) {
                        dmap.type = dpad_map_t::eType_Button;
                } else {
                        ASSERT_THROW(false, "Invalid dpad type: " << type);
                }
                dmap.index[dpad_map_t::eUp] = getByte(dpad, "up");
                dmap.index[dpad_map_t::eDown] = getByte(dpad, "down");
                dmap.index[dpad_map_t::eLeft] = getByte(dpad, "left");
                dmap.index[dpad_map_t::eRight] = getByte(dpad, "right");

                // if we have a blank type, determine 2 or 4 potentiometer
                if (dpad_map_t::eType_Invalid == dmap.type) {
                        if (dmap.index[dpad_map_t::eUp] == dmap.index[dpad_map_t::eDown]) {
                                dmap.type = dpad_map_t::eType_2Pot;
                        } else {
                                dmap.type = dpad_map_t::eType_4Pot;
                        }
                }

                // flip any axes?
                const char * flipX = getOptionalString(dpad, "flipX", "");
                const char * flipY = getOptionalString(dpad, "flipY", "");
                dmap.flipX = getBooleanFromString(flipX);
                dmap.flipY = getBooleanFromString(flipY);

                //dmap.dump(logical);
                ASSERT_THROW(dmap.isValid(),
                    "Gamepad mapping for '" << logical << "' is not valid");
                m_dpads[logical] = dmap;
        }
        //DPRINTF("  Read %d directional pad (dpad) mappings",
        //    (int) m_dpads.size());
}



////////////////////////////////////////////////////////////////////////////////
//
//      Mapping -- gamepad::Map class interface methods
//
////////////////////////////////////////////////////////////////////////////////

const button_map_t *
Mapping::getButtonMapping
(
IN const char * logicalName
)
const
throw()
{
        ASSERT(logicalName, "null");

        buttons_t::const_iterator i = m_buttons.find(logicalName);
        if (m_buttons.end() == i)
                return NULL;    // name not found

        return &i->second;
}



const joystick_map_t *
Mapping::getJoystickMapping
(
IN const char * logicalName
)
const
throw()
{
        ASSERT(logicalName, "null");

        joysticks_t::const_iterator i = m_joysticks.find(logicalName);
        if (m_joysticks.end() == i)
                return NULL;    // joystick of that name not found
        return &i->second;
}



const pot_map_t *
Mapping::getPotMapping
(
IN const char * logicalName
)
const
throw()
{
        ASSERT(logicalName, "null");

        pots_t::const_iterator i = m_pots.find(logicalName);
        if (m_pots.end() == i)
                return NULL;    // potentiometer of that name not found
        return &i->second;
}



const dpad_map_t *
Mapping::getDpadMapping
(
IN const char * logicalName
)
const
throw()
{
        ASSERT(logicalName, "null");

        dpads_t::const_iterator i = m_dpads.find(logicalName);
        if (m_dpads.end() == i)
                return NULL;    // dpad of that name not found
        return &i->second;
}



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

smart_ptr<Map>
readMap
(
IN const Datahash * hash
)
{
        ASSERT(hash, "null");

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

        local->initialize(hash);

        return local;
}



};      // gamepad namespace