gamepad-type.h

Go to the documentation of this file.

/*
 * gamepad-type.h
 *
 * 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 Type object.  This is a completely data-driven concept.
 */

#ifndef GAMEPAD_GAMEPAD_TYPE_H__
#define GAMEPAD_GAMEPAD_TYPE_H__


// includes --------------------------------------------------------------------
#include "datahash/datahash.h"
#include "nstream/nstream.h"


namespace gamepad {


/// \ingroup gamepadlib
/*@{*/

/// A type of input object (button, joystick, potentiometer, directional pad...)
enum eInputType {
        eInput_Button   = 0x01,  ///< simple on/off button or switch
        eInput_Joystick = 0x02,  ///< 2-axis joystick
        eInput_Pot      = 0x04,  ///< potentiometer (1-dimensional variable)
        eInput_Dpad     = 0x08,  ///< directional pad

        // keep this last!
        eInput_Invalid  = 0x00
};



/// a type of gamepad (Dualshock, Xbox, N64, etc)
class Type {
public:
        // virtual destructor --------------------------------------------------
        virtual ~Type(void) throw();

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

        /// returns the ID of this type.  This should be a UUID
        virtual const char * getId(void) const throw() = 0;

        /// returns the name of this type of gamepad.  This is usually a string
        ///     such as "XBox 360" or "Playstation 3" or "Nintendo 64", etc.
        ///     The string is intended for internal use only (so it is stable
        ///     across locales, but therefore not appropriate for display).
        virtual const char * getName(void) const throw() = 0;

        /// given a type of input (button, joystick, etc.) this returns the
        ///     number of such inputs available on this type of gamepad. 
        virtual int getInputCount(IN eInputType type) const throw() = 0;

        /// given the index of a particular input, returns the logical name.
        ///     Returns NULL in some cases (no such type, etc.).  Program will
        ///     crash (with error) if you pass in a bad index, so call
        ///     Type::getInputCount() first!
        virtual const char * getLogicalName(IN eInputType type,
                                IN int idx) const throw() = 0;

        /// returns all known logical inputs on the gamepad, regardless of type
        virtual void getAllInputs(OUT VecString& logicalNames) const = 0;

        /// given a logical name for an input object on the gamepad, returns
        ///     all of the types (eInputType values OR'd together).  Returns
        ///     eInput_Invalid if name is unrecognized.
        virtual eInputType getInputTypes(IN const char * logicalName) const throw() = 0;

        /// given a logical name and input type, return index for that type.
        ///     returns -1 if logical name or type are incorrect
        virtual int getLogicalIndex(IN const char * logicalName,
                                IN eInputType type) throw() = 0;

        /// get the logical name for the most commonly used button
        virtual const char * getMainButton(void) const throw() = 0;

        /// get the vector graphics (vgfx) request that describes this
        ///     controller.  Returns NULL if no vector graphics request was
        ///     provided.  See vgfx::processRequest() for details about the
        ///     vgfx request stream.
        virtual smart_ptr<nstream::Stream> getVgfx(void) = 0;

        /// debugging only: dump type information to stdout
        virtual void dump(void) const throw() = 0;
};


/// maps from name --> gamepad type object
typedef std::map<std::string, smart_ptr<Type> > gamepad_type_map_t;



////////////////////////////////////////////////////////////////////////////////
//
//      Gamepad API
//
////////////////////////////////////////////////////////////////////////////////

/// read a gamepad type object from the given datahash
smart_ptr<Type> readType(IN nstream::Stream * stream);


/// load all gamepad objects in the specified folder, and add them to the
///     provided map (keyed by name, see gamepad::Type::getName() ).
/// This method is NOT recursive (it does not parse subfolders if any).
void addGamepadTypesInFolderToMap(IO nstream::Folder * folder,
                                IO gamepad_type_map_t& map);



};      // gamepad namespace

#endif  // GAMEPAD_GAMEPAD_TYPE_H__