Control.h

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.
//
//-----------------------------------------------------------------------------------


#ifndef INPUT_CONTROL_H
#define INPUT_CONTROL_H

#include <PVLE/Export.h>
#include <PVLE/Util/Util.h>
#include <bitset>
#include <osg/Vec3>


class PVLE_EXPORT ControlState {
public:
    static const UINT NB_USER_SWITCHES = 30;        

    enum ESwitchId {
        NONE=0,         
        FORWARD, BACKWARD, LEFT, RIGHT, STRAFE_LEFT, STRAFE_RIGHT, UP, DOWN,
        ROLL_LEFT, ROLL_RIGHT,
        JUMP, CROUCH,
        FAST_TOGGLE, ALWAYS_FAST,               // Equivalent of RUN / ALWAYS_RUN
        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,

        MAX_STARNDARD_SWITCH,                               
        USER_SWITCH_0 = MAX_STARNDARD_SWITCH,               

        MAX_SWITCH = USER_SWITCH_0 + NB_USER_SWITCHES       
    };


    enum EAxisId {
        AXIS_X=0, AXIS_Y, AXIS_Z,
        AXIS_SCROLL_1, AXIS_SCROLL_2, AXIS_SCROLL_3, AXIS_SCROLL_4,
        MAX_AXIS        // Do not remove this one
    };

    ControlState();

    ControlState & operator+=(ESwitchId switchId) { set(switchId); return *this; }
    ControlState & operator-=(ESwitchId switchId) { reset(switchId); return *this; }
    bool operator[](ESwitchId switchId) const { return vSwitchs[switchId]; }

    void set(ESwitchId switchId) { if (vSwitchs[switchId]) return; vSwitchs[switchId] = true; ++nbSwitchesOn; }
    void reset(ESwitchId switchId) { if (!vSwitchs[switchId]) return; ASSERT(nbSwitchesOn>0); vSwitchs[switchId] = false; --nbSwitchesOn; }
    bool get(ESwitchId switchId) const { return vSwitchs[switchId]; }
    void resetAllSwitches() { vSwitchs.reset(); nbSwitchesOn = 0; }

    void setAxis(EAxisId axis, float val) { ASSERT(axis>=0 && axis<MAX_AXIS); pAxis[axis] = val; }
    void addToAxis(EAxisId axis, float val) { ASSERT(axis>=0 && axis<MAX_AXIS); pAxis[axis] += val; }
    float getAxis(EAxisId axis) const { ASSERT(axis>=0 && axis<MAX_AXIS); return pAxis[axis]; }
    void resetAxis(EAxisId axis) { ASSERT(axis>=0 && axis<MAX_AXIS); pAxis[axis] = 0; }
    void resetAllAxis();
    bool isAxisZero(EAxisId axis, float epsilon = 0.0001f) { ASSERT(axis>=0 && axis<MAX_AXIS); return (fabs(pAxis[axis]) < epsilon); }

    bool testAnySwitchOn() const { return nbSwitchesOn>0; }

    bool testAnyAxisOn(float epsilon = 1e-4f) const {
        //for(UINT i=0; i<MAX_AXIS; ++i) if (fabs(pAxis[i]) > epsilon) return true;
        BOOST_FOREACH(float axisValue, pAxis) if (fabs(axisValue) > epsilon) return true;
        return false;
    }

    bool testAnyControlOn(float epsilon = 0.0001f) const { return testAnySwitchOn() || testAnyAxisOn(epsilon); }

    void setPointer(float pointerX, float pointerY) { pointer = osg::Vec3f(pointerX, pointerY, 0); }
    void setPointer(const osg::Vec3f & pointer) { this->pointer = pointer; }
    osg::Vec3f getPointer() const { return pointer; }
    float getPointerX() const { return pointer.x(); }
    float getPointerY() const { return pointer.y(); }
    osg::Vec3f getPickPosition() const { return pickPos; }
    void setPickPosition(const osg::Vec3f & pickPos) { this->pickPos = pickPos; }

protected:
    UINT nbSwitchesOn;
    std::bitset<MAX_SWITCH> vSwitchs;
    float pAxis[MAX_AXIS];
    osg::Vec3f pointer;
    osg::Vec3f pickPos;
};


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

#include <PVLE/Config.h>
#ifdef PVLE_NETWORKING
    #include <tnl/tnlNetEvent.h>
#endif

class /*PVLE_EXPORT*/ ControlEvent {
public:
    enum EEventType {
        SWITCH_DOWN, SWITCH_UP, AXIS,
        LAST_NETWORK_EVENT,                 
        // Following events are not sent over the network:
        GFX_FRAME = LAST_NETWORK_EVENT, GFX_RESIZE
    };

    ControlEvent(double time, EEventType type) : time(time), type(type) {}
    ControlEvent(double time, ControlState::ESwitchId switchId, int unmappedKey, bool down) : time(time) { data.switchId.first = switchId; data.switchId.second = unmappedKey; type = down ? SWITCH_DOWN : SWITCH_UP; }
    ControlEvent(double time, ControlState::EAxisId axisId, float movement) : time(time), type(AXIS) { data.axisMovement.first = axisId; data.axisMovement.second = movement; }
    ControlEvent(const ControlEvent & v) : time(v.time), type(v.type) {     // , data(data)
        if (type == AXIS) data.axisMovement = v.data.axisMovement;
        else if (type == SWITCH_DOWN || type == SWITCH_UP) data.switchId = v.data.switchId;
    }

    inline double getTime() const { return time; }
    inline EEventType getType() const { return type; }

    inline ControlState::ESwitchId getSwitchId() const { ASSERT(type == SWITCH_DOWN || type == SWITCH_UP); return data.switchId.first; }
    inline int getUnmappedKey() const { ASSERT(type == SWITCH_DOWN || type == SWITCH_UP); return data.switchId.second; }
    inline ControlState::EAxisId getAxisId() const { ASSERT(type == AXIS); return data.axisMovement.first; }
    inline float getAxisMovement() const { ASSERT(type == AXIS); return data.axisMovement.second; }

protected:
    double time;            
    EEventType type;        

    union TEventDependantData {
        TrivialPair<ControlState::ESwitchId, int> switchId;
        TrivialPair<ControlState::EAxisId, float> axisMovement;
    };
    TEventDependantData data;
};

typedef std::vector<ControlEvent> ControlEventList;


#ifdef PVLE_NETWORKING
class PVLE_EXPORT NetControlEvent : public ControlEvent, public TNL::NetEvent {
public:
    TNL_DECLARE_CLASS(NetControlEvent);

    NetControlEvent(double time, EEventType type) : ControlEvent(time, type), NetEvent(GuaranteedOrdered, DirClientToServer) {}
    NetControlEvent(double time, ControlState::ESwitchId switchId, int unmappedKey, bool down) : ControlEvent(time, switchId, unmappedKey, down), NetEvent(GuaranteedOrdered, DirClientToServer) {}
    NetControlEvent(double time, ControlState::EAxisId axisId, float movement) : ControlEvent(time, axisId, movement), NetEvent(GuaranteedOrdered, DirClientToServer) {}
    NetControlEvent(const ControlEvent & v) : ControlEvent(v) {}

    virtual void pack(TNL::EventConnection * pConnection, TNL::BitStream * pStream);
    virtual void unpack(TNL::EventConnection * pConnection, TNL::BitStream * pStream);
    virtual void process(TNL::EventConnection * pConnection);

protected:
    friend class TNL::NetClassRepInstance<NetControlEvent>;
    NetControlEvent() : ControlEvent(-1, SWITCH_DOWN), NetEvent(GuaranteedOrdered, DirClientToServer) {}

};

#else   // PVLE_NETWORKING

//#include <osg/Referenced>

class PVLE_EXPORT NetControlEvent : public ControlEvent/*, public osg::Referenced*/ {
public:
    NetControlEvent(double time, EEventType type) : ControlEvent(time, type) {}
    NetControlEvent(double time, ControlState::ESwitchId switchId, int unmappedKey, bool down) : ControlEvent(time, switchId, unmappedKey, down) {}
    NetControlEvent(double time, ControlState::EAxisId axisId, float movement) : ControlEvent(time, axisId, movement) {}
    NetControlEvent(const ControlEvent & v) : ControlEvent(v) {}
};

#endif  // PVLE_NETWORKING

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

namespace TNL {
#ifdef PVLE_NETWORKING
    class EventConnection;
#else
    typedef void EventConnection;
#endif
}


class Controler {
public:
    Controler() : pConnection(NULL) { vEvents.reserve(INITIAL_EVENTS_SIZE); }
    ControlState & getControlState() { return state; }
    const ControlState & getControlState() const { return state; }

    ControlEventList::const_iterator getEventBegin() const { return vEvents.begin(); }
    ControlEventList::const_iterator getEventEnd() const { return vEvents.end(); }
    void clearEvents() { vEvents.clear(); }
    void clearAxis() { state.resetAllAxis(); }
    void clear() { vEvents.clear(); state.resetAllAxis(); }


    inline void doSwitch(double curTime, ControlState::ESwitchId switchId, int unmappedKey, bool pushed) {
        vEvents.push_back(ControlEvent(curTime, switchId, unmappedKey, pushed));
        if (pushed) state += switchId;
        else state -= switchId;
    }
    inline void doSwitchPush(double curTime, ControlState::ESwitchId switchId, int unmappedKey) {
        vEvents.push_back(ControlEvent(curTime, switchId, unmappedKey, true));
        state += switchId;
    }
    inline void doSwitchRelease(double curTime, ControlState::ESwitchId switchId, int unmappedKey) {
        vEvents.push_back(ControlEvent(curTime, switchId, unmappedKey, false));
        state -= switchId;
    }
    inline void doSwitchPR(double curTime, ControlState::ESwitchId switchId, int unmappedKey) {
        vEvents.push_back(ControlEvent(curTime, switchId, unmappedKey, true));
        vEvents.push_back(ControlEvent(curTime, switchId, unmappedKey, false));
        state -= switchId;
    }

    inline void axisMove(double curTime, ControlState::EAxisId axisId, float movement) {
#ifndef NO_AXIS_EVENT
        vEvents.push_back(ControlEvent(curTime, axisId, movement));
#endif
        state.addToAxis(axisId, movement);
    }

#ifdef PVLE_NETWORKING

    void setClientConnection(TNL::EventConnection * pConnection) { this->pConnection = pConnection; }
    TNL::EventConnection * getClientConnection() { return pConnection; }
    const TNL::EventConnection * getClientConnection() const { return pConnection; }
#endif

protected:
    static const UINT INITIAL_EVENTS_SIZE = 8;      
    ControlState state;             
    ControlEventList vEvents;       

    TNL::EventConnection * pConnection;                         
};


// ------------------------------------------------------------------------------------------------
// Bindings
// ------------------------------------------------------------------------------------------------


#include <PVLE/Util/Util.h>
#include <map>

typedef std::map<int, ControlState::ESwitchId> Bindings;
const UINT BUTTON_MOUSE_MODIFIER = 0x10000;     // 0xFFFF is maximum for keyboard in osgGA
const UINT BUTTON_JOY_MODIFIER = 0x10020;
// If another is added, think about updating saving / loading functions


namespace boost {
namespace serialization {
    class access;
}
}

class AxisControl {
public:
    AxisControl() : axisId(ControlState::MAX_AXIS), accel(1), sensitivity(1), deadzone(0) {}

    AxisControl(ControlState::EAxisId axisId, float accel, float sensitivity, float deadzone)
        : axisId(axisId), accel(accel), sensitivity(sensitivity), deadzone(deadzone) {}

    ControlState::EAxisId axisId;
    float accel;            
    float sensitivity;      
    float deadzone;         

private:
    //friend class boost::serialization::access;
    //template<class Archive>
    //void serialize(Archive & ar, const unsigned int version) {
    //  ar & axisId;
    //  ar & accel;
    //  ar & sensitivity;
    //  ar & deadzone;
    //}
};

typedef std::map<int, AxisControl> AxisBindings;
const UINT AXIS_MOUSE_MODIFIER = 0;     // Set this to a value like 0x10 to allow keyboard to have axis
const UINT AXIS_JOY_MODIFIER = 0x10;


#include <boost/filesystem/path.hpp>

PVLE_EXPORT void saveBindings(const Bindings & k, const AxisBindings & a, const boost::filesystem::path & path, const char ** userSwitchesNames = NULL, UINT nbUserSwitchesNames = 0, UINT userBindingsFileVersion = 0);

PVLE_EXPORT bool loadBindings(Bindings & k, AxisBindings & a, const boost::filesystem::path & path, const char ** userSwitchesNames = NULL, UINT nbUserSwitchesNames = 0, UINT userBindingsFileVersion = 0);

PVLE_EXPORT void setDefaultBindings(Bindings & k, AxisBindings & a);


#endif  // INPUT_CONTROL_H

---