gamepad-type.cpp

Go to the documentation of this file.

/*
 * gamepad-type.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.
 *
 *
 * Simple data-driven gamepad type objects.
 */

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

#include "common/wave_ex.h"
#include "datahash/datahash_util.h"
#include "datahash/datahash_text.h"
#include "perf/perf.h"
#include "util/file.h"


namespace gamepad {


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


const char * s_extension                = "gamepad";


struct input_entry_t {
        eInputType      type;
        const char *    name;   // for debugging etc
        const char *    key;    // key name as appears in type input files
};


static const input_entry_t s_inputTypes[] = {
        // list of types
        //      type            name                    key
        { eInput_Button,        "button",               "button" },
        { eInput_Joystick,      "joystick",             "joystick" },
        { eInput_Pot,           "potentiometer",        "pot" },
        { eInput_Dpad,          "directionalPad",       "dpad" },

        // keep this last!
        { eInput_Invalid,       NULL,           NULL }
};



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

////////////////////////////////////////////////////////////////////////////////
//
//      GType -- class that implements the gamepad::Type interface
//
////////////////////////////////////////////////////////////////////////////////

class GType : public Type {
public:
        // constructor, destructor ---------------------------------------------
        GType(void) throw();
        ~GType(void) throw();

        // public class methods ------------------------------------------------
        void initialize(IN nstream::Stream * stream);

        // gamepad::Type class interface methods -------------------------------
        const char * getId(void) const throw() { return m_id.c_str(); }
        const char * getName(void) const throw() { return m_name.c_str(); }
        int getInputCount(IN eInputType type) const throw();
        const char * getLogicalName(IN eInputType type,
                                IN int idx) const throw();
        void getAllInputs(OUT VecString& names) const;
        eInputType getInputTypes(IN const char * logicalName) const throw();
        int getLogicalIndex(IN const char * logicalName,
                                IN eInputType type) throw();
        const char * getMainButton(void) const throw();
        smart_ptr<nstream::Stream> getVgfx(void);
        void dump(void) const throw();

private:
        // private typedefs ----------------------------------------------------
        typedef std::map<eInputType, smart_ptr<VecString> > type_names_t;

        struct type_rec_t {
                type_rec_t(void) throw() { this->clear(); }
                void clear(void) throw() {
                                types = eInput_Invalid;
                                buttonIndex = joyIndex = potIndex = dpadIndex = -1;
                        }

                // data fields
                eInputType      types;
                int             buttonIndex;
                int             joyIndex;
                int             potIndex;
                int             dpadIndex;
        };

        typedef std::map<std::string, type_rec_t> type_map_t;

        // private helper methods ----------------------------------------------
        void addInputs(IN eInputType type,
                                IN const VecString& names);
        int getIndex(IN eInputType type,
                                IN const char * name);

        // private member data -------------------------------------------------
        std::string             m_id;
        std::string             m_name;
        std::string             m_mainButton;   // name of most common used btn
        type_names_t            m_names;        // type --> list of names
        type_map_t              m_types;        // logical name --> object types
        smart_ptr<nstream::File> m_vgfxFile;    // vgfx file (if we have one)
};



GType::GType(void)
throw()
{
}



GType::~GType(void)
throw()
{
}



void
GType::initialize
(
IN nstream::Stream * stream
)
{
        ASSERT(stream, "null");
        ASSERT_THROW(stream->good(), "bad stream");

        // read the datahash from this stream
        std::istream& in = stream->getStream();
        ASSERT_THROW(in.good(), "bad stream?");

        smart_ptr<Datahash> logical = readHashFromStream("(root)", in);
        ASSERT(logical, "null");

        //DPRINTF("Reading logical gamepad type...");

        m_id = getString(logical, "id");
        //DPRINTF("  id: '%s'", m_id.c_str());

        // read the name
        m_name = getString(logical, "name");
        //DPRINTF("  name: '%s'", m_name.c_str());

        // read the most commonly used (main) button
        m_mainButton = getString(logical, "mainButton");
        //DPRINTF("  main button: '%s'", m_mainButton.c_str());

        // read the vgfx file (if any)
        ASSERT(!m_vgfxFile, "already have vgfx file?");
        const char * vgfxFile = getOptionalString(logical, "vgfx", NULL);
        if (vgfxFile) {
                smart_ptr<nstream::File> file = stream->getFile();
                ASSERT(file, "null");
                const char * thisFile = file->getName();
                //DPRINTF("Starting with gamepad file: '%s'", thisFile);
                std::string relPath = getPathRelativeTo(thisFile, vgfxFile);
                //DPRINTF("path to vgfx file: '%s'", relPath.c_str());
                smart_ptr<nstream::Manager> mgr = file->getManager();
                ASSERT(mgr, "null");
                m_vgfxFile = mgr->getEntry(relPath.c_str());
        }

        // read all input objects
        for (const input_entry_t * p = s_inputTypes; p->key; ++p) {
                smart_ptr<VecString> vec = new VecString;
                ASSERT(vec, "out of memory");

                // any entries with this key at all?
                if (!logical->count(p->key))
                        continue;       // skip this one

                // grab all logical names with this key from input hash
                getStringValues(logical, p->key, *vec);

                // save in our map
                m_names[p->type] = vec;

                // update our master map of all names/types
                this->addInputs(p->type, *vec);
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      GType -- gamepad::Type class interface methods
//
////////////////////////////////////////////////////////////////////////////////

int
GType::getInputCount
(
IN eInputType type
)
const
throw()
{
        type_names_t::const_iterator i = m_names.find(type);
        if (m_names.end() == i) {
                return 0;       // no such type found
        }
        ASSERT(i->second, "null vector in map");
        return i->second->size();
}



const char *
GType::getLogicalName
(
IN eInputType type,
IN int idx
)
const
throw()
{
        ASSERT(idx >= 0, "Bad index: %d", idx);

        type_names_t::const_iterator i = m_names.find(type);
        if (m_names.end() == i) {
                DPRINTF("cannot get logical name: no such type!");
                return NULL;
        }
        ASSERT(i->second, "null vector in map");
        ASSERT(idx < (int) i->second->size(),
            "Input index is too large: %d", idx);

        return i->second->operator[](idx).c_str();
}



void
GType::getAllInputs
(
OUT VecString& logicalNames
)
const
{
        logicalNames.clear();

        for (type_map_t::const_iterator i = m_types.begin(); i != m_types.end();
             ++i) {
                logicalNames.push_back(i->first);
        }
}



eInputType
GType::getInputTypes
(
IN const char * logicalName
)
const
throw()
{
        ASSERT(logicalName, "null");

        type_map_t::const_iterator i = m_types.find(logicalName);
        if (m_types.end() == i) {
                // logical name not recognized
                return eInput_Invalid;
        }
        const type_rec_t& tr = i->second;
        ASSERT(eInput_Invalid != tr.types, "should be valid type");

        return tr.types;
}



int
GType::getLogicalIndex
(
IN const char * logicalName,
IN eInputType type
)
throw()
{
        ASSERT(logicalName, "null");

        type_map_t::iterator i = m_types.find(logicalName);
        if (m_types.end() == i) {
                // DPRINTF("Logical name not recognized: '%s'", logicalName);
                return -1;
        }

        type_rec_t& tr = i->second;
        if (!(type & tr.types)) {
                DPRINTF("Logical name is not of correct type");
                return -1;
        }

        // okay this should match!  Look for it...
        switch (type) {
        case eInput_Button:
                if (-1 == tr.buttonIndex) {
                        tr.buttonIndex = getIndex(eInput_Button, logicalName);
                }
                return tr.buttonIndex;

        case eInput_Joystick:
                if (-1 == tr.joyIndex) {
                        tr.joyIndex = getIndex(eInput_Joystick, logicalName);
                }
                return tr.joyIndex;

        case eInput_Pot:
                if (-1 == tr.potIndex) {
                        tr.potIndex = getIndex(eInput_Pot, logicalName);
                }
                return tr.potIndex;

        case eInput_Dpad:
                if (-1 == tr.dpadIndex) {
                        tr.dpadIndex = getIndex(eInput_Dpad, logicalName);
                }
                return tr.dpadIndex;

        default:
                ASSERT(false, "bad type: %d", type);
        }

        ASSERT(false, "bad type: %d", type);
        return -1;
}



const char *
GType::getMainButton
(
void
)
const
throw()
{
        return m_mainButton.c_str();
}



smart_ptr<nstream::Stream>
GType::getVgfx
(
void
)
{
        if (!m_vgfxFile) {
                DPRINTF("Gamepad has no vector graphics file");
                return NULL;
        }

        // open a stream
        smart_ptr<nstream::Stream> stream = m_vgfxFile->openStream();
        ASSERT(stream, "null");
        ASSERT_THROW(stream->good(), "bad stream?");
        return stream;
}



void
GType::dump
(
void
)
const
throw()
{
        DPRINTF("Gamepad type: %s", this->getName());
        DPRINTF("  Contains %d logical inputs", (int) m_types.size());

        for (type_map_t::const_iterator i = m_types.begin(); i != m_types.end();
             ++i) {
                std::string out = i->first;
                out += ":";
                const type_rec_t& tr = i->second;
                for (const input_entry_t * p = s_inputTypes; p->key; ++p) {
                        if (tr.types & p->type) {
                                out += " ";
                                out += p->name;
                        }
                }
                DPRINTF("    %s", out.c_str());
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      GType -- private helper methods
//
////////////////////////////////////////////////////////////////////////////////

void
GType::addInputs
(
IN eInputType type,
IN const VecString& names
)
{
        // update master map of name-->types with given list of named inputs
        for (VecString::const_iterator i = names.begin(); i != names.end();
             ++i) {
                const char * name = i->c_str();
                type_map_t::iterator k = m_types.find(name);
                if (m_types.end() == k) {
                        // this is the first instance of this name we've seen
                        type_rec_t tr;
                        tr.types = type;
                        m_types[name] = tr;
                } else {
                        // name is already in map, update type
                        type_rec_t& tr = k->second;
                        tr.types = (eInputType) (tr.types | type);
                }
        }
}



int
GType::getIndex
(
IN eInputType type,
IN const char * logicalName
)
{
        ASSERT(eInput_Invalid != type, "invalid type");
        ASSERT(logicalName, "null");

        type_names_t::iterator i = m_names.find(type);
        ASSERT_THROW(m_names.end() != i, "bad type: " << type);

        const VecString * names = i->second;
        ASSERT(names, "null");
        int nNames = names->size();
        for (int j = 0; j < nNames; ++j) {
                const char * name = names->operator[](j).c_str();
                if (!strcmp(name, logicalName)) {
                        return j;
                }
        }

        // not found in list!
        ASSERT(false, "logical name not in type list");
        return -1;
}



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

smart_ptr<Type>
readType
(
IN nstream::Stream * stream
)
{
        ASSERT(stream, "null");

        // create a gamepad object based on the logical configuration
        smart_ptr<GType> local = new GType;
        ASSERT(local, "out of memory");
        local->initialize(stream);

        // all done!
        return local;
}



void
addGamepadTypesInFolderToMap
(
IO nstream::Folder * folder,
IO gamepad_type_map_t& map
)
{
        ASSERT(folder, "null");

        // loop through all entries in the folder
        folder->resetIteration();
        for (;;) {
                smart_ptr<nstream::Entry> entry = folder->getNextChild();
                if (!entry)
                        break;          // end of iteration

                // upcast to file object
                smart_ptr<nstream::File> file = entry;
                if (!file)
                        continue;       // skip any non-file objects

                // is this a gamepad file?
                if (!hasExtension(file->getName(), s_extension))
                        continue;       // not a gamepad file

                // get stream
                smart_ptr<nstream::Stream> stream = file->openStream();

                try {
                        THROW(stream, "failed to open stream");
                        THROW(stream->good(), "bad stream");

                        smart_ptr<Type> gt = readType(stream);
                        THROW(gt, "null gamepad type object returned");
                        map[gt->getName()] = gt;

                } catch (std::exception& e) {
                        WAVE_EX(wex);
                        wex << "Failed to read gamepad stream: '";
                        wex << file->getName() << "' in folder '";
                        wex << folder->getName() << "'\n";
                        wex << e.what();
                }
        }
}



};      // gamepad namespace