Control.cpp

Go to the documentation of this file.

//-----------------------------------------------------------------------------------
//
// Pro-Vocation Light Engine (PVLE)
// Copyright (C) 2007-2009  Sukender, KinoX & Buzib
// For more information, contact us : sukender@free.fr
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// For any use that is not compatible with the terms of the GNU 
// General Public License, please contact the authors for alternative
// licensing options.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//-----------------------------------------------------------------------------------

#include <PVLE/Config.h>
#include <PVLE/Input/Control.h>
#include <PVLE/Util/Singleton.h>
#include <boost/static_assert.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/cast.hpp>

#ifdef PVLE_USE_INTROSPECTION
#   include <osgIntrospection/Reflection>
#   include <osgIntrospection/Type>
#   include <osgDB/DynamicLibrary>
#endif

#include <osg/ref_ptr>

// ---------------------------------------------------------------------

#include <algorithm>

void ControlState::resetAllAxis() { std::fill(pAxis, pAxis+MAX_AXIS, 0.f); }

ControlState::ControlState() : nbSwitchesOn(0) {
    resetAllSwitches();
    resetAllAxis();
}

// ---------------------------------------------------------------------

const char * switchesNames[/*ControlState::MAX_STARNDARD_SWITCH*/] = {      // Dev note : keep size uncommented helps debugging since there is a static assertion below.
    "NONE",
    "FORWARD", "BACKWARD", "LEFT", "RIGHT", "STRAFE_LEFT", "STRAFE_RIGHT", "UP", "DOWN",
    "ROLL_LEFT", "ROLL_RIGHT",
    "JUMP", "CROUCH",
    "FAST_TOGGLE", "ALWAYS_FAST",
    "FASTER", "SLOWER",
    "FIRE1", "FIRE2", "FIRE3", "FIRE4", "FIRE5",
    "WEAPON_NEXT", "WEAPON_PREV", "WEAPON_TOGGLE",
    "WEAPON1", "WEAPON2", "WEAPON3", "WEAPON4", "WEAPON5", "WEAPON6", "WEAPON7", "WEAPON8", "WEAPON9", "WEAPON10",
    "WEAPON11", "WEAPON12", "WEAPON13", "WEAPON14", "WEAPON15", "WEAPON16", "WEAPON17", "WEAPON18", "WEAPON19", "WEAPON20",
    "DROP_WEAPON", "DROP_ALTERNATE",
    "TARGET", "TARGET_NEXT", "TARGET_PREV", "SHOW_INFO",
    "VIEW_NEXT", "VIEW_PREV",
    "ZOOM_IN", "ZOOM_OUT",
    "VIEW1", "VIEW2", "VIEW3", "VIEW4", "VIEW5", "VIEW6", "VIEW7", "VIEW8", "VIEW9", "VIEW10", "VIEW11", "VIEW12", "VIEW13", "VIEW14", "VIEW15",
    "PAUSE",
    "SCREENSHOT",
    "TOGGLE_FULLSCREEN",
    "BRAKE", "RESET",
    "MENU", "SCORE_MENU",
    "OK", "CANCEL"
};

BOOST_STATIC_ASSERT(sizeof(switchesNames) / sizeof(char *) == ControlState::MAX_STARNDARD_SWITCH);      // If failed, then there is a mistake is the above array.

const char * axisNames[ControlState::MAX_AXIS] = {
    "AXIS_X", "AXIS_Y", "AXIS_Z",
    "AXIS_SCROLL_1", "AXIS_SCROLL_2", "AXIS_SCROLL_3", "AXIS_SCROLL_4"
};



#ifdef PVLE_NETWORKING

#include <tnl/tnlCertificate.h>     // [Sukender] Needed for DLL compilation, but I don't know why...
#include <tnl/tnlBitStream.h>
#include <PVLE/Network/PVLEGhostConnection.h>

TNL_IMPLEMENT_NETEVENT(NetControlEvent, TNL::NetClassGroupGameMask, 0);

void NetControlEvent::pack(TNL::EventConnection * pConnection, TNL::BitStream * pStream) {
    ASSERT(type < LAST_NETWORK_EVENT);          // Cannot send a non-network event !
    pStream->writeEnum(type, LAST_NETWORK_EVENT);
    if (type == AXIS) {
        // Axis
        pStream->writeEnum(data.axisMovement.first, ControlState::MAX_AXIS);
        pStream->write(data.axisMovement.second);
    } else {
        // Switch
        pStream->writeEnum(data.switchId.first, ControlState::MAX_SWITCH);
        pStream->write(data.switchId.second);
    }
}

void NetControlEvent::unpack(TNL::EventConnection * pConnection, TNL::BitStream * pStream) {
    type = static_cast<EEventType>(pStream->readEnum(LAST_NETWORK_EVENT));
    if (type == AXIS) {
        // Axis
        data.axisMovement.first = static_cast<ControlState::EAxisId>(pStream->readEnum(ControlState::MAX_AXIS));
        pStream->read(&data.axisMovement.second);
    } else {
        // Switch
        data.switchId.first = static_cast<ControlState::ESwitchId>(pStream->readEnum(ControlState::MAX_SWITCH));
        pStream->read(&data.switchId.second);
    }
}

void NetControlEvent::process(TNL::EventConnection * pConnection) {
    boost::polymorphic_downcast<PVLEGhostConnection *>(pConnection)->receiveControlEvent(*this);
}
#endif


// Without spaces (until we code a real parser... ;p)
const char * const VERSION_TEXT  = "Version:";
const char * const SWITCHES_TEXT = "-----Key_bindings-----";
const char * const AXIS_TEXT     = "-----Axis_bindings-----";
const UINT BINDINGS_FILE_VERSION = 5;       // Increment this when the parser is no more compatible with previous files.



#include <fstream>
//#include <boost/archive/text_oarchive.hpp>
//#include <boost/archive/text_iarchive.hpp>
#include <osgGA/GUIEventAdapter>

#ifdef PVLE_USE_INTROSPECTION

class OSGWrapperLoader : public Util::Singleton<OSGWrapperLoader> {
public:
    void openLibrary(const std::string& str) { osg::ref_ptr<osgDB::DynamicLibrary> & lib = getPointerForName(str); if (lib.valid()) return; lib = osgDB::DynamicLibrary::loadLibrary(createLibraryNameForWrapper(str)); }
    void closeLibrary(const std::string& str) { osg::ref_ptr<osgDB::DynamicLibrary> & lib = getPointerForName(str); if (!lib.valid()) return; lib = NULL; }

protected:
    osg::ref_ptr<osgDB::DynamicLibrary> osgLib, osgDBLib, osgFXLib, osgGALib, osgParticleLib, osgProducerLib, osgSimLib, osgTerrainLib, osgTextLib, osgUtilLib;

    osg::ref_ptr<osgDB::DynamicLibrary> & getPointerForName(const std::string& str) {
        if (str == "osg") return osgLib;
        if (str == "osgDB") return osgDBLib;
        if (str == "osgFX") return osgFXLib;
        if (str == "osgGA") return osgGALib;
        if (str == "osgParticle") return osgParticleLib;
        if (str == "osgProducer") return osgProducerLib;
        if (str == "osgSim") return osgSimLib;
        if (str == "osgTerrain") return osgTerrainLib;
        if (str == "osgText") return osgTextLib;
        if (str == "osgUtil") return osgUtilLib;
        THROW_TRACED_EXCEPTION("Unknown library (" + str + ")");
    }

    // borrowed from osgDB...
    static std::string createLibraryNameForWrapper(const std::string& ext) {
        #if defined(WIN32)
            // !! recheck evolving Cygwin DLL extension naming protocols !! NHV
            #ifdef __CYGWIN__
                return "cygosgwrapper_"+ext+".dll";
            #elif defined(__MINGW32__)
                return "libosgwrapper_"+ext+".dll";
            #else
                #ifdef _DEBUG
                    return "osgwrapper_"+ext+"d.dll";
                #else
                    return "osgwrapper_"+ext+".dll";
                #endif
            #endif
        #elif macintosh
            return "osgwrapper_"+ext;
        #elif defined(__hpux__)
            // why don't we use PLUGIN_EXT from the makefiles here?
            return "osgwrapper_"+ext+".sl";
        #else
            return "osgwrapper_"+ext+".so";
        #endif
    }
};


typedef osgIntrospection::EnumLabelMap LabelMap;

class KeyMap {
public:
    KeyMap() {
        try {
            OSGWrapperLoader::instance().openLibrary("osgGA");
            const osgIntrospection::Type & introKeysEnum = osgIntrospection::Reflection::getType("osgGA::GUIEventAdapter::KeySymbol");
            ASSERT(introKeysEnum.isEnum());
            map = &introKeysEnum.getEnumLabels();
            ASSERT(map);
        } catch (osgIntrospection::TypeNotFoundException e) {
            OSGWrapperLoader::instance().closeLibrary("osgGA");
            THROW_TRACED_EXCEPTION(e.what());
        }
    }

    std::string operator()(int key) const {
        osgIntrospection::EnumLabelMap::const_iterator itKey = map->find(key);
        if (itKey != map->end())         return itKey->second;      // enum key
        if (key > BUTTON_JOY_MODIFIER)   return "JOY_"   + boost::lexical_cast<std::string>(key-BUTTON_JOY_MODIFIER);       // Joy button
        if (key > BUTTON_MOUSE_MODIFIER) return "MOUSE_" + boost::lexical_cast<std::string>(key-BUTTON_MOUSE_MODIFIER);     // Mouse button
        if (key >=32 && key<=255)        return std::string()+static_cast<char>(key);                                       // Key (not enum). Ex: 'a'-'z'
        LOG_ERROR << "Invalid key number found in bindings (" << key << ")" << std::endl;
        return std::string();
    }

protected:
    friend class InvKeyMap;
    const osgIntrospection::EnumLabelMap * map;
};

class InvKeyMap {
public:
    InvKeyMap() {
        // Create a reverse map
        const KeyMap keyMap;
        for(osgIntrospection::EnumLabelMap::const_iterator it=keyMap.map->begin(), itEnd=keyMap.map->end(); it!=itEnd; ++it) map.insert(std::pair<std::string, int>(it->second, it->first));
    }

    int operator()(const std::string & key) const {
        std::map<std::string, int>::const_iterator itKey = map.find(key);
        if (itKey != map.end()) return itKey->second;       // enum key
        if (key.length() == 1)  return key[0];              // Key (not enum). Ex: 'a'-'z'
        if (key.substr(0, 4) == "JOY_") {
            try {
                return BUTTON_JOY_MODIFIER + boost::lexical_cast<int>(key.substr(4, std::string::npos));
            } catch (boost::bad_lexical_cast e) {
                LOG_ERROR << "Invalid joystick button found in bindings file (" << key << ")" << std::endl;
                return 0;
            }
        }
        if (key.substr(0, 6) == "MOUSE_") {
            try {
                return BUTTON_MOUSE_MODIFIER + boost::lexical_cast<int>(key.substr(6, std::string::npos));
            } catch (boost::bad_lexical_cast e) {
                LOG_ERROR << "Invalid mouse button found in bindings file (" << key << ")" << std::endl;
                return 0;
            }
        }
        LOG_ERROR << "Invalid key found in bindings file (" << key << ")" << std::endl;
        return 0;
    }

protected:
    std::map<std::string, int> map;
};

#else

class KeyMap {
public:
    KeyMap() {}
    inline std::string operator()(int key) const { return boost::lexical_cast<std::string>(key); }
};

class InvKeyMap {
public:
    InvKeyMap() {}
    inline int operator()(const std::string & key) const {
        try {
            return boost::lexical_cast<int>(key);
        } catch (boost::bad_lexical_cast e) {
            LOG_ERROR << "Invalid binding key (" << key << ")" << std::endl;
            return 0;
        }
    }
};

#endif


//#include <boost/serialization/extended_type_info_typeid.hpp>      // IMPORTANT ! This include is *NEEDED* in order the code to compile. When not used with RTTI, extended_type_info_no_rtti is required
//#include <boost/archive/text_oarchive.hpp>
//#include <boost/archive/text_iarchive.hpp>
//#include <boost/archive/xml_oarchive.hpp>
//#include <boost/archive/xml_iarchive.hpp>
//#include <boost/serialization/map.hpp>


void saveBindings(const Bindings & k, const AxisBindings & a, const boost::filesystem::path & path, const char ** userSwitchesNames, UINT nbUserSwitchesNames, UINT userBindingsFileVersion) {
    DBG_TRY_BLOCK_START
    ASSERT(nbUserSwitchesNames <= ControlState::NB_USER_SWITCHES);

    // Get key labels (using introspection)
    const KeyMap keyMap;

    // Open
    std::ofstream ofs(path.native_file_string().c_str());

    // Write
    ofs << VERSION_TEXT << " " << BINDINGS_FILE_VERSION << " " << userBindingsFileVersion << "\n";

    ofs << SWITCHES_TEXT << "\n";
    const char * switchText;
    for(Bindings::const_iterator it=k.begin(), itEnd=k.end(); it!=itEnd; ++it) {
        ASSERT(it->second != ControlState::MAX_SWITCH);
        if (it->second < ControlState::MAX_STARNDARD_SWITCH) switchText = switchesNames[it->second];
        else {
            UINT switchTextIndex = it->second - ControlState::USER_SWITCH_0;
            ASSERT(userSwitchesNames && switchTextIndex < nbUserSwitchesNames);
            switchText = userSwitchesNames[switchTextIndex];
        }
        std::string keyStr(keyMap(it->first));
        if (!keyStr.empty()) ofs << switchText << " " << keyStr << "\n";
    }
    ofs << AXIS_TEXT << "\n";
    for(AxisBindings::const_iterator it=a.begin(), itEnd=a.end(); it!=itEnd; ++it) {
        ASSERT(it->second.axisId != ControlState::MAX_AXIS);
        ofs << axisNames[it->second.axisId] << " " << it->second.accel << " " << it->second.sensitivity << " " << it->second.deadzone << " ";
        if (it->first >= AXIS_JOY_MODIFIER) ofs << "JOY_AXIS_" << (it->first-AXIS_JOY_MODIFIER) << "\n";
        else if (it->first >= AXIS_MOUSE_MODIFIER) ofs << "MOUSE_AXIS_" << (it->first-AXIS_MOUSE_MODIFIER) << "\n";
        else ofs << "KEYB_AXIS_" << it->first << "\n";
    }

#ifdef PVLE_USE_INTROSPECTION
    OSGWrapperLoader::instance().closeLibrary("osgGA");     // Close will not fail if already closed.
#endif

    DBG_TRY_BLOCK_END
}


struct SimpleStrComp {
    bool operator()(const char* a, const char* b) const { ASSERT(a && b); return strcmp(a, b) <0; }
};


bool loadBindings(Bindings & k, AxisBindings & a, const boost::filesystem::path & path, const char ** userSwitchesNames, UINT nbUserSwitchesNames, UINT userBindingsFileVersion) {
    DBG_TRY_BLOCK_START
    ASSERT(nbUserSwitchesNames <= ControlState::NB_USER_SWITCHES);

    k.clear();
    a.clear();

    // First create a reverse map "text => int" for switches (standard and custom)
    typedef std::map<const char*, ControlState::ESwitchId, SimpleStrComp> TTextToSwitch;
    TTextToSwitch switchesId;
    const char ** itName = switchesNames;
    for(UINT i=0; i<ControlState::MAX_STARNDARD_SWITCH; ++i, ++itName) switchesId.insert(std::pair<const char*, ControlState::ESwitchId>(*itName, static_cast<ControlState::ESwitchId>(i)));
    itName = userSwitchesNames;
    for(UINT i=0; i<nbUserSwitchesNames; ++i, ++itName) switchesId.insert(std::pair<const char*, ControlState::ESwitchId>(*itName, static_cast<ControlState::ESwitchId>(ControlState::USER_SWITCH_0 + i)));

    // Create a reverse map for axis
    typedef std::map<const char*, ControlState::EAxisId, SimpleStrComp> TTextToAxis;
    TTextToAxis axisId;
    itName = axisNames;
    for(UINT i=0; i<ControlState::MAX_AXIS; ++i, ++itName) axisId.insert(std::pair<const char*, ControlState::EAxisId>(*itName, static_cast<ControlState::EAxisId>(i)));

    // Get an invert map for keys
    const InvKeyMap ikeyMap;

    // Variables used to read
    std::string switchName, keyName;
    AxisControl aControl;
    TTextToSwitch::const_iterator itSwitch;
    TTextToAxis::const_iterator itAxis;

    // Open
    std::ifstream ifs(path.native_file_string().c_str());
    std::string read;

    UINT version = UINT_MAX;
    UINT userVersion = UINT_MAX;
    ifs >> read >> version;     // Read text
    ASSERT(read == VERSION_TEXT);

    if (version >= 4) ifs >> userVersion;       // Old format: <4 - userVersion did not exist (only one version number)
    else userVersion = 0;
    if (version != BINDINGS_FILE_VERSION || userVersion != userBindingsFileVersion) {
        LOG_ERROR << "Version of bindings file (" << version << "-" << userVersion << ") and executable (" << BINDINGS_FILE_VERSION << "-" << userBindingsFileVersion << ") does not match. Using default parameters." << std::endl;
        setDefaultBindings(k, a);
        return false;
    }

    ifs >> read;        // Read text
    ASSERT(read == SWITCHES_TEXT);

    ifs >> switchName >> keyName;
    std::ifstream::pos_type posSave;
    while(switchName != AXIS_TEXT && ifs.good()) {
        itSwitch = switchesId.find(switchName.c_str());
        if (itSwitch == switchesId.end()) LOG_ERROR << "Invalid control found in key bindings file (" << switchName << ")" << std::endl;
        else {
            // Switch is ok, try to read key
            int keyID = ikeyMap(keyName);
            if (keyID) k[keyID] = itSwitch->second;
            posSave = ifs.tellg();
            ifs >> switchName >> keyName;
        }
    }

    ifs.seekg(posSave);

    ifs >> read;        // Read text
    ASSERT(read == AXIS_TEXT);

    // Rename switchName to axis (not used anymore)
#define axisName switchName
    ifs >> axisName >> aControl.accel >> aControl.sensitivity >> aControl.deadzone >> keyName;
    while(ifs.good()) {
        itAxis = axisId.find(axisName.c_str());
        if (itAxis == axisId.end()) LOG_ERROR << "Invalid axis found in key bindings file (" << axisName << ")" << std::endl;
        // Axis is ok, try to read key
        else {
            aControl.axisId = itAxis->second;

            if (keyName.substr(0, 9) == "JOY_AXIS_") {
                try {
                    a[AXIS_JOY_MODIFIER + boost::lexical_cast<int>(keyName.substr(9, std::string::npos))] = aControl;
                } catch (boost::bad_lexical_cast e) { LOG_ERROR << "Invalid joystick axis found in bindings file (" << keyName << ")" << std::endl; }
            }
            else if (keyName.substr(0, 11) == "MOUSE_AXIS_") {
                try {
                    a[AXIS_MOUSE_MODIFIER + boost::lexical_cast<int>(keyName.substr(11, std::string::npos))] = aControl;
                } catch (boost::bad_lexical_cast e) { LOG_ERROR << "Invalid mouse axis found in bindings file (" << keyName << ")" << std::endl; }
            }
            else if (keyName.substr(0, 10) == "KEYB_AXIS_") {
                try {
                    a[boost::lexical_cast<int>(keyName.substr(10, std::string::npos))] = aControl;
                } catch (boost::bad_lexical_cast e) { LOG_ERROR << "Invalid keyboard axis found in bindings file (" << keyName << ")" << std::endl; }
            }
            else {
                LOG_ERROR << "Invalid axis found in bindings file (" << keyName << ")" << std::endl;
            }

            ifs >> axisName >> aControl.accel >> aControl.sensitivity >> aControl.deadzone >> keyName;
        }
    }

#ifdef PVLE_USE_INTROSPECTION
    OSGWrapperLoader::instance().closeLibrary("osgGA");     // Close will not fail if already closed.
#endif

#undef axisName

    return true;
    DBG_TRY_BLOCK_END
}

void setDefaultBindings(Bindings & k, AxisBindings & a) {
    // --- Keys & buttons ---
    k['z'] = ControlState::FORWARD;
    k['s'] = ControlState::BACKWARD;
    k['q'] = ControlState::STRAFE_LEFT;
    k['d'] = ControlState::STRAFE_RIGHT;
    k['o'] = ControlState::LEFT;
    k['p'] = ControlState::RIGHT;
    k['a'] = ControlState::UP;
    k['w'] = ControlState::DOWN;
    k['c'] = ControlState::CROUCH;
    k['x'] = ControlState::DROP_WEAPON;
    k['w'] = ControlState::DROP_ALTERNATE;

    k[osgGA::GUIEventAdapter::KEY_Shift_L] = ControlState::FAST_TOGGLE;
    k[osgGA::GUIEventAdapter::KEY_Shift_R] = ControlState::FAST_TOGGLE;

    k['+'] = ControlState::FASTER;
    k['-'] = ControlState::SLOWER;
    k[osgGA::GUIEventAdapter::KEY_KP_Add] = ControlState::FASTER;
    k[osgGA::GUIEventAdapter::KEY_KP_Subtract] = ControlState::SLOWER;
    k[osgGA::GUIEventAdapter::KEY_Page_Up] = ControlState::FASTER;
    k[osgGA::GUIEventAdapter::KEY_Page_Down] = ControlState::SLOWER;

    k[osgGA::GUIEventAdapter::KEY_Control_L] = ControlState::FIRE1;
    //k[osgGA::GUIEventAdapter::KEY_Space] = ControlState::FIRE2;
    k[osgGA::GUIEventAdapter::KEY_Space] = ControlState::BRAKE;
    k[osgGA::GUIEventAdapter::KEY_BackSpace] = ControlState::RESET;
    //k[osgGA::GUIEventAdapter::KEY_Escape] = ControlState::MENU;
    k[osgGA::GUIEventAdapter::KEY_F1] = ControlState::MENU;
    k[osgGA::GUIEventAdapter::KEY_F2] = ControlState::SCORE_MENU;
    k[osgGA::GUIEventAdapter::KEY_Tab] = ControlState::SCORE_MENU;
    k[osgGA::GUIEventAdapter::KEY_Delete] = ControlState::CANCEL;
    k[osgGA::GUIEventAdapter::KEY_Pause] = ControlState::PAUSE;

    // Warning : mouse buttons numbering begins with 1.
    k[BUTTON_MOUSE_MODIFIER + osgGA::GUIEventAdapter::LEFT_MOUSE_BUTTON] = ControlState::FIRE1;
    k[BUTTON_MOUSE_MODIFIER + osgGA::GUIEventAdapter::MIDDLE_MOUSE_BUTTON] = ControlState::JUMP;
    k[BUTTON_MOUSE_MODIFIER + osgGA::GUIEventAdapter::RIGHT_MOUSE_BUTTON] = ControlState::JUMP;
    //k[BUTTON_MOUSE_MODIFIER + 3] = ControlState::JUMP;        // Standard mouse = Unknown button (buttons are bitfield)

    //k[AXIS_JOY_MODIFIER + 0] = ControlState::;

    // --- Axis ---
    a[AXIS_MOUSE_MODIFIER + 0] = AxisControl(ControlState::AXIS_X, 1.3, 80, 1);
    a[AXIS_MOUSE_MODIFIER + 1] = AxisControl(ControlState::AXIS_Y, 1.3, -80, 1);
    a[AXIS_MOUSE_MODIFIER + 2] = AxisControl(ControlState::AXIS_SCROLL_1, 1, 1, 0);     // Mouse wheel 1
    a[AXIS_MOUSE_MODIFIER + 3] = AxisControl(ControlState::AXIS_SCROLL_2, 1, 1, 0);     // Mouse wheel 2

    //a[AXIS_JOY_MODIFIER + 0] = AxisControl(ControlState::, 1, 1, 0);
}

---