ControlMapper.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_MAPPER_H
#define INPUT_CONTROL_MAPPER_H

#include <PVLE/Export.h>
#include <PVLE/Input/Control.h>
#include <osg/Referenced>
#include <osg/ref_ptr>
#include <osgGA/GUIEventHandler>
#include <vector>
#include <map>

//namespace osg {
//  class NodePath;
//}

namespace osgViewer {
    class View;
}



class ControlEventHandler : public virtual osg::Referenced {
public:
    //virtual bool handleEvent(const ControlEvent & ce) =0;
    virtual bool handleEvent(NetControlEvent * pEvent, TNL::EventConnection * pConnection) =0;

    virtual void onAddedToControler(Controler * pControler) {}
    virtual void onRemovedFromControler(const Controler * pControler) {}

protected:
    virtual ~ControlEventHandler() {}
};


class ControlHandler : public ControlEventHandler {
public:
    ControlHandler() : pControler(NULL) {}

    virtual void onAddedToControler(Controler * pControler) { this->pControler = pControler; }
    virtual void onRemovedFromControler(const Controler * pControler) { this->pControler = NULL; }

    virtual void handleFrame(double elapsed) =0;

protected:
    Controler * pControler;         
};




class PVLE_EXPORT ControlMapper : public Controler, public osgGA::GUIEventHandler {
public:
    ControlMapper()
        : pBindings(NULL), pAxisBindings(NULL), prevMouseX(0), prevMouseY(0), pointerMouse(false), sendUnmappedKeyboard(true), sendUnmappedButtons(false) {}
    ControlMapper(const Bindings * pBindings, const AxisBindings * pAxisBindings)
        : pBindings(pBindings), pAxisBindings(pAxisBindings), prevMouseX(0), prevMouseY(0), pointerMouse(false), sendUnmappedKeyboard(true), sendUnmappedButtons(false) {}
    //virtual bool handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa, osg::Object * pObject, osg::NodeVisitor * pNV);
    virtual bool handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa);

    typedef std::vector<osg::observer_ptr<ControlEventHandler> > THandlerList;
    const THandlerList & getHandlerList(UINT orderIndex) const;

    enum EHandlerOrderIndexes {
        HANDLER_ORDER_CRITICAL,     
        HANDLER_ORDER_MENU,         
        HANDLER_ORDER_UNIT          
    };

    void addHandlerBack(ControlEventHandler * pHandler, UINT orderIndex) { getOrCreateHandlerList(orderIndex).push_back(pHandler); pHandler->onAddedToControler(this); }
    //void addHandlerFront(ControlEventHandler * pHandler, UINT orderIndex) { getOrCreateHandlerList(orderIndex).push_front(pHandler); pHandler->onAddedToControler(this); }
    void removeHandler(ControlEventHandler * pHandler);
    void removeHandler(ControlEventHandler * pHandler, UINT orderIndex);
    void removeHandlers(UINT orderIndex);
    void replaceHandler(ControlEventHandler * pOldHandler, ControlEventHandler * pNewHandler, UINT orderIndex);
    void clearHandlers() { handlerLists.clear(); }

    const Bindings * getBindings() const { return pBindings; }
    void setBindings(const Bindings * pBindings) { this->pBindings = pBindings; }
    const AxisBindings * getAxisBindings() const { return pAxisBindings; }
    void setAxisBindings(const AxisBindings * pAxisBindings) { this->pAxisBindings = pAxisBindings; }
    void setBindings(const Bindings * pBindings, const AxisBindings * pAxisBindings) { this->pBindings = pBindings; this->pAxisBindings = pAxisBindings; }


    bool isPointerMouse() { return pointerMouse; }
    void enablePointerMouse() { pointerMouse = true; }
    void disablePointerMouse() { pointerMouse = false; }
    void computePickPos(osgViewer::View & view, osg::NodePath * pPickNodePath = NULL);

    void setSendUnmappedKeyboard(bool state) { sendUnmappedKeyboard = state; }
    void setSendUnmappedButtons(bool state)  { sendUnmappedButtons  = state; }
    bool getSendUnmappedKeyboard() const { return sendUnmappedKeyboard; }
    bool getSendUnmappedButtons()  const { return sendUnmappedButtons; }


    void onControlEventReceived(const ControlEvent & ce) {
        ASSERT(ce.getType() != ControlEvent::GFX_FRAME && ce.getType() != ControlEvent::GFX_RESIZE);        // Those events are not allowed across the network.
        if (ce.getType() == ControlEvent::AXIS) processHandlerListsOrAxisMove(ce.getTime(), ce.getAxisId(), ce.getAxisMovement());
        else {
            ASSERT(ce.getType() == ControlEvent::SWITCH_DOWN || ce.getType() == ControlEvent::SWITCH_UP);
            processHandlerListsOrDoSwitch(ce.getTime(), ce.getSwitchId(), ce.getUnmappedKey(), ce.getType() == ControlEvent::SWITCH_DOWN);
        }
    }

protected:
    typedef std::pair<UINT, THandlerList> THandlerListP;        
    typedef std::map<UINT, THandlerList> THandlerListsList;     
    THandlerListsList handlerLists;             

    // ----- These methods are not public : callers must not be able to add/remove handlers without calling ControlEventHandler::onAddedToControler() -----
    THandlerList & getHandlerList(UINT orderIndex);
    THandlerList & getOrCreateHandlerList(UINT orderIndex);         
    // ----- (end) -----

    typedef std::pair<THandlerList *, THandlerList::iterator> THandlerLocation;     // Handler, iterator on corresponding item in list
    THandlerLocation findHandler(ControlEventHandler * pHandler);

    bool processHandlerLists(const ControlEvent & ce);

    void removeDeletedHandlers();

    bool processHandlerListsOrAppend(const ControlEvent & ce) {
        if (!processHandlerLists(ce)) { vEvents.push_back(ce); return false; }
        return true;
    }
    inline void processHandlerListsOrDoSwitch(double curTime, ControlState::ESwitchId switchId, int unmappedKey, bool pushed) {
        if (!processHandlerListsOrAppend(ControlEvent(curTime, switchId, unmappedKey, pushed))) {
            if (pushed) state += switchId;
            else state -= switchId;
        }
    }
    inline void processHandlerListsOrAxisMove(double curTime, ControlState::EAxisId axisId, float movement) {
#ifndef NO_AXIS_EVENT
        state.addToAxis(axisId, movement);
#else
        if (!processHandlerListsOrAppend( ControlEvent(curTime, axisId, movement) )) {
            state.addToAxis(axisId, movement);
        }
#endif
    }

    bool pointerMouse;                  
    bool sendUnmappedKeyboard;          
    bool sendUnmappedButtons;           
    float computeMouseMovement(float mouseDiff, const AxisControl & ac);        
    float prevMouseX, prevMouseY;

    const Bindings * pBindings;         
    const AxisBindings * pAxisBindings; 
};


#endif  // INPUT_CONTROL_MAPPER_H

---