ControlMapper.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/Util/Assert.h>
#include <PVLE/Input/ControlMapper.h>
#ifdef PVLE_NETWORKING
    #include <tnl/tnlEventConnection.h>
#endif

#ifndef CONTROL_MAPPER_WX
    // Platform-specific way to get (absolute) mouse position.
    #ifdef WIN32

        #ifndef WIN32_LEAN_AND_MEAN
            #define WIN32_LEAN_AND_MEAN     // Exclude rarely-used stuff from Windows headers
        #endif
        #include <windows.h>

        inline void getMousePosition(int * pX, int * pY) {
            POINT pt;
            GetCursorPos(&pt);
            if (pX) *pX = pt.x;
            if (pY) *pY = pt.y;
        }
    #elif defined(PVLE_USE_X11)
        #include "X11/Xutil.h"
        #include <PVLE/Util/Singleton.h>
        class DisplaySingleton : public Util::Singleton<DisplaySingleton> {
        public:
            DisplaySingleton() : display(NULL) {}
            ~DisplaySingleton() { close(); }
            inline Display * get() {
                if (!display) { display = XOpenDisplay(NULL); ASSERT(display); }
            }
            inline void close() {
                if (display) { XCloseDisplay(display); display = NULL; }
            }
            Display * display;
        };

        inline void getMousePosition(int * pX, int * pY) {
            XMotionEvent xev;
            Window root, child;
            Display * display = DisplaySingleton::instance().get();
            XQueryPointer(display,
                DefaultRootWindow(display),
                &root, &child,
                &(xev.x_root), &(xev.y_root),
                &(xev.x),      &(xev.y),
                &(xev.state));
            *pX = xev.x_root;
            *pY = xev.y_root;
        }
    #else
        // If platform is not supported in PVLE, fall back to a library that handles the job (wxWidgets).
        // To get a platform-specific implementation, look at wxWidgets code: wxGetMousePosition() in src/PLATFORM/window.cpp 

        // To link with wxWidgets for wxGetMousePosition():
        // Libs: wxmsw28d_core.lib wxbase28d.lib
        // Lib path: $(WX_PATH)\lib\vc_lib; $(WX_PATH)/lib/vc_dll (or any other compiler)

        #pragma message("(Platform-specific) Not implemented PVLE: getMousePosition(). Fallback to wxWidgets implementation.")
        #define CONTROL_MAPPER_WX
    #endif
#endif

#ifdef CONTROL_MAPPER_WX
    #include <wx/utils.h>
    inline void getMousePosition(int * pX, int * pY) { return wxGetMousePosition(pX, pY); }
#endif



#ifdef WIN32
    bool appHasFocus(osgGA::GUIActionAdapter &aa, int mouseX, int mouseY) {
        // wxWidgets implementation :
        //return wxTheApp->IsActive();
        return GetActiveWindow() != NULL;           // Works well, but that's absolutly not cross-platform
    }

#else
    #pragma message("(Platform-specific) Not implemented PVLE: appHasFocus(). Fallback to 'always true'. Maybe something interesing in wxWidgets implementation?")

    bool appHasFocus(osgGA::GUIActionAdapter &aa, int mouseX, int mouseY) {
        // wxWidgets implementation :
        //return wxTheApp->IsActive();

//#include <boost/cast.hpp>
//#include <osgViewer/Viewer>
        //osg::Camera * pCam = boost::polymorphic_downcast<osgViewer::Viewer *>(&aa)->getCameraWithFocus();
        //if (!pCam) return false;
        //const osg::GraphicsContext::Traits * pTraits = pCam->getGraphicsContext()->getTraits();
        //if (mouseX<pTraits->x || mouseX>pTraits->x+pTraits->width ||
        //  mouseY<pTraits->y || mouseX>pTraits->y+pTraits->height) return false;
        return true;
    }
#endif



ControlMapper::THandlerList & ControlMapper::getHandlerList(UINT orderIndex) {
    THandlerListsList::iterator it = handlerLists.find(orderIndex);
    if (it == handlerLists.end()) THROW_TRACED_FMT_EXCEPTION("No handler list exists with orderIndex == %1%", orderIndex);
    return it->second;
}

const ControlMapper::THandlerList & ControlMapper::getHandlerList(UINT orderIndex) const {
    THandlerListsList::const_iterator it = handlerLists.find(orderIndex);
    if (it == handlerLists.end()) THROW_TRACED_FMT_EXCEPTION("No handler list exists with orderIndex == %1%", orderIndex);
    return it->second;
}

ControlMapper::THandlerList & ControlMapper::getOrCreateHandlerList(UINT orderIndex) {
    THandlerListsList::iterator it = handlerLists.find(orderIndex);
    if (it == handlerLists.end()) {
        std::pair<THandlerListsList::iterator, bool> ret = handlerLists.insert(THandlerListP(orderIndex, THandlerList()));      // Copies an empty vector. Not clean but fast to write...
        ASSERT(ret.second);     // Is insertion ok ?
        return ret.first->second;
    }
    return it->second;
}

ControlMapper::THandlerLocation ControlMapper::findHandler(ControlEventHandler * pHandler) {
    THandlerList::iterator itSub;
    for(THandlerListsList::iterator it=handlerLists.begin(), itEnd=handlerLists.end(); it!=itEnd; ++it) {
        THandlerList & list = it->second;
        itSub = std::find(list.begin(), list.end(), pHandler);
        if (itSub != list.end()) return THandlerLocation(&list, itSub);     // Found !
    }
    return THandlerLocation(NULL, THandlerList::iterator());
}

void ControlMapper::removeHandler(ControlEventHandler * pHandler) {
    THandlerLocation location = findHandler(pHandler);
    if (location.first != NULL) {
        // Found !
        pHandler->onRemovedFromControler(this);
        location.first->erase(location.second);
    } else LOG_ERROR << "Cannot remove given handler (does not exist in this ControlMapper)" << std::endl;
}

void ControlMapper::removeHandler(ControlEventHandler * pHandler, UINT orderIndex) {
    THandlerList & list = getHandlerList(orderIndex);
    THandlerList::iterator it = std::find(list.begin(), list.end(), pHandler);
    if (it != list.end()) {
        // Found !
        pHandler->onRemovedFromControler(this);
        list.erase(it);
    } else LOG_ERROR << "Cannot remove given handler (does not exist in this ControlMapper, where orderIndex == " << orderIndex << ")" << std::endl;
}

void ControlMapper::replaceHandler(ControlEventHandler * pOldHandler, ControlEventHandler * pNewHandler, UINT orderIndex) {
    if (pOldHandler == pNewHandler) return;

    if (!pOldHandler) {
        // Nothing to remove, simply add
        addHandlerBack(pNewHandler, orderIndex);
        return;
    }
    if (!pNewHandler) {
        // Nothing to add, simply remove
        removeHandler(pNewHandler, orderIndex);
        return;
    }

    // Replace
    THandlerList & list = getHandlerList(orderIndex);
    THandlerList::iterator it = std::find(list.begin(), list.end(), pOldHandler);
    if (it == list.end()) THROW_TRACED_EXCEPTION("Cannot replace handler (old handler not found");

    pOldHandler->onRemovedFromControler(this);
    ASSERT(*it == pOldHandler);
    *it = pNewHandler;
    pNewHandler->onAddedToControler(this);
}

void ControlMapper::removeHandlers(UINT orderIndex) {
    THandlerListsList::iterator it = handlerLists.find(orderIndex);
    if (it == handlerLists.end()) return;       // Nothing to remove
    BOOST_FOREACH(osg::observer_ptr<ControlEventHandler> & handler, it->second) {
        handler->onRemovedFromControler(this);
    }
    handlerLists.erase(it);
}

void ControlMapper::removeDeletedHandlers() {
    THandlerList::iterator itSub;
    for(THandlerListsList::iterator it=handlerLists.begin(); it!=handlerLists.end(); ) {
        THandlerList & list = it->second;
        for(itSub=list.begin(); itSub!=list.end(); ) {
            if (!itSub->valid()) itSub = list.erase(itSub);
            else ++itSub;
        }
        if (it->second.empty()) {
            THandlerListsList::iterator itNext = it;
            ++itNext;
            handlerLists.erase(it);
            it = itNext;
        }
        else ++it;
    }
}

bool ControlMapper::processHandlerLists(const ControlEvent & ce) {
    DBG_TRY_BLOCK_START

#ifdef PVLE_NETWORKING
    TNL::RefPtr<NetControlEvent> pEvent = new NetControlEvent(ce);
#else
    NetControlEvent * pEvent = new NetControlEvent(ce);
#endif

    //BOOST_FOREACH(THandlerListP & list, handlerLists) {
    bool handlerDeleted = false;
    for(THandlerListsList::iterator it=handlerLists.begin(), itEnd=handlerLists.end(); it!=itEnd; ++it) {
        BOOST_FOREACH(osg::observer_ptr<ControlEventHandler> & handler, it->second) {
            if (!handler) handlerDeleted = true;
            else if (handler->handleEvent(pEvent, pConnection)) {
                if (handlerDeleted) removeDeletedHandlers();
#ifndef PVLE_NETWORKING
                delete pEvent;
#endif
                return true;
            }
        }
    }
    if (handlerDeleted) removeDeletedHandlers();
#ifndef PVLE_NETWORKING
    delete pEvent;
#endif
    return false;

    DBG_TRY_BLOCK_END
}


bool ControlMapper::handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa) {
    DBG_TRY_BLOCK_START

    ASSERT(pBindings && pAxisBindings);         // This method must not be called if no bindings are defined.

    double time = ea.time();
    bool pushed;        // Ugly temp variable, but avoids doing some tests twice.

    // Keys and buttons
    pushed = ea.getEventType() == osgGA::GUIEventAdapter::KEYDOWN;          // pushed = key pressed
    if (pushed || ea.getEventType() == osgGA::GUIEventAdapter::KEYUP) {
        int key = ea.getKey();
        ControlState::ESwitchId mappedSwitch;

        int keyLower = key;
        if (keyLower >= 'A' && keyLower <= 'Z') keyLower += 'a' - 'A';      // To lower for keyboard messages (remove 'shift')
        if (keyLower < 32) keyLower += 96;                                  // Same thing for control codes (remove 'control')

        Bindings::const_iterator it = pBindings->find(keyLower);
        if (it == pBindings->end()) {
            // Key not mapped
            if (sendUnmappedKeyboard) mappedSwitch = ControlState::NONE;
            else return false;
        }
        else mappedSwitch = it->second;
        processHandlerListsOrDoSwitch(time, mappedSwitch, key, pushed);
        return true;
    }

    pushed = ea.getEventType() == osgGA::GUIEventAdapter::PUSH;             // pushed = mouse button pressed
    if (pushed || ea.getEventType() == osgGA::GUIEventAdapter::RELEASE) {
        int key = BUTTON_MOUSE_MODIFIER + ea.getButton();
        ControlState::ESwitchId mappedSwitch;
        Bindings::const_iterator it = pBindings->find(key);
        if (it == pBindings->end()) {
            // Button not mapped
            if (sendUnmappedButtons) mappedSwitch = ControlState::NONE;
            else return false;
        }
        else mappedSwitch = it->second;
        processHandlerListsOrDoSwitch(time, mappedSwitch, key, pushed);
        return true;
    }

    // Mouse : handle movement on each frame (accumulate)
    // Kinox said OS generates mouse movement EVENTS only for big movements OR small ones after a defined amount of time. It seems to be true... So we're handling mouse movement on each frame, getting the real mouse position each time.
    if (ea.getEventType() == osgGA::GUIEventAdapter::FRAME) {
        // Frame event
        processHandlerListsOrAppend(ControlEvent(time, ControlEvent::GFX_FRAME));

        // Mouse movement
        int mouseX, mouseY;
        getMousePosition(&mouseX, &mouseY);

        if (appHasFocus(aa, mouseX, mouseY))
        {
            if (mouseX!=prevMouseX || mouseX!=prevMouseY) {         // If mouse moved
                //if (fabs(mouseX) < 0.9f && fabs(mouseY) < 0.9f)   // If movement is not too much
                {
                    AxisBindings::const_iterator it0 = pAxisBindings->find(AXIS_MOUSE_MODIFIER + 0);
                    AxisBindings::const_iterator it1 = pAxisBindings->find(AXIS_MOUSE_MODIFIER + 1);

                    // Note : we call addToAxis (not setAxis) because it's the user's role to determine when to reset the axis (typically on each physical frame, with inertia)
                    if (it0 != pAxisBindings->end()) processHandlerListsOrAxisMove(time, it0->second.axisId, computeMouseMovement(mouseX - prevMouseX, it0->second));
                    if (it1 != pAxisBindings->end()) processHandlerListsOrAxisMove(time, it1->second.axisId, computeMouseMovement(mouseY - prevMouseY, it1->second));
                }
                state.setPointer(ea.getX(), ea.getY());
                //state.setPointer(mouseX, mouseY);
                prevMouseX = mouseX;
                prevMouseY = mouseY;

                // Recenter mouse if needed
                if (!pointerMouse) {
                    // --- OSG 1.2 code ---
                    //if (fabs(mouseX) > .5f || fabs(mouseY) > .5f) {
                    //  prevMouseX = 0;
                    //  prevMouseY = 0;
                    //  aa.requestWarpPointer(0,0);
                    //}

                    // --- OSG 2.0 code ---
                    float absX = ea.getXmin() + ea.getXmax()/2.f;
                    float absY = ea.getYmin() + ea.getYmax()/2.f;
                    aa.requestWarpPointer(absX, absY);
                    //prevMouseX = 2.0f*(absX-ea.getXmin())/(ea.getXmax()-ea.getXmin())-1.0f;
                    //prevMouseY = 2.0f*(absY-ea.getYmin())/(ea.getYmax()-ea.getYmin())-1.0f;
                    //prevMouseX = absX + ea.getWindowX();      // Does not work because getWindowX() returns 0
                    //prevMouseY = absY + ea.getWindowY();
                    getMousePosition(&mouseX, &mouseY);
                    prevMouseX = mouseX;
                    prevMouseY = mouseY;
                }
            }
        }
 
        return false;       // Never say FRAME event is handled
    }

    // Wheels : do not apply acceleration / deadzone, only sensitivity
    if (ea.getEventType() == osgGA::GUIEventAdapter::SCROLL)
    {
        pushed = ea.getScrollingMotion() == osgGA::GUIEventAdapter::SCROLL_UP;              // pushed = scroll up
        if (pushed || ea.getScrollingMotion() == osgGA::GUIEventAdapter::SCROLL_DOWN) {
            AxisBindings::const_iterator it = pAxisBindings->find(AXIS_MOUSE_MODIFIER + 2);
            if (it == pAxisBindings->end()) return false;       // Scroll axis not mapped
            processHandlerListsOrAxisMove(time, it->second.axisId, it->second.sensitivity * pushed ? 1 : -1);
            return true;
        }
        else {
            pushed = ea.getScrollingMotion() == osgGA::GUIEventAdapter::SCROLL_RIGHT;       // pushed = scroll right
            if (pushed || ea.getScrollingMotion() == osgGA::GUIEventAdapter::SCROLL_LEFT) {
                AxisBindings::const_iterator it = pAxisBindings->find(AXIS_MOUSE_MODIFIER + 3);
                if (it == pAxisBindings->end()) return false;       // Scroll axis not mapped
                processHandlerListsOrAxisMove(time, it->second.axisId, it->second.sensitivity * pushed ? 1 : -1);
                return true;
            }
            else if (ea.getScrollingMotion() == osgGA::GUIEventAdapter::SCROLL_2D) {
                AxisBindings::const_iterator itX = pAxisBindings->find(AXIS_MOUSE_MODIFIER + 2);
                AxisBindings::const_iterator itY = pAxisBindings->find(AXIS_MOUSE_MODIFIER + 3);
                if (itX != pAxisBindings->end()) processHandlerListsOrAxisMove(time, itX->second.axisId, itX->second.sensitivity * ea.getScrollingDeltaX());
                if (itY != pAxisBindings->end()) processHandlerListsOrAxisMove(time, itY->second.axisId, itY->second.sensitivity * ea.getScrollingDeltaY());
                if (itX == pAxisBindings->end() || itY != pAxisBindings->end()) return false;       // At least one scroll axis not mapped
                return true;        // Both scroll axis mapped
            }
        }

        // All control paths have a 'return' statement
        //return false;
    }

    // Other
    if (ea.getEventType() == osgGA::GUIEventAdapter::RESIZE) {
        ControlEvent ce (time, ControlEvent::GFX_RESIZE);
        if (processHandlerLists(ce)) {
            vEvents.push_back(ce);
            return true;
        }
        return false;
    }

    return false;

    DBG_TRY_BLOCK_END
}



float ControlMapper::computeMouseMovement(float mouseDiff, const AxisControl & ac) {
    // Skip computation movement if it isn't significant
    if ( fabs(mouseDiff) < ac.deadzone) return 0;

    mouseDiff /= 1000.f;        // Mouse is now in pixels, not in [-1;1], so we scale it reasonably (to avoid sensitivity parameters such as 0.08)

    // Two methods : (Move*Sensitivity)^Accel (seems best), or (Move^Accel)*Sensitivity
    float beforePow = mouseDiff * ac.sensitivity;
    return copySign( powf(fabs(beforePow), ac.accel), beforePow );
    //return copySign( powf(fabs(mouseDiff), ac.accel) * ac.sensitivity, mouseDiff );
}


#include <osgUtil/LineSegmentIntersector>
#include <osgViewer/View>

void ControlMapper::computePickPos(osgViewer::View & view, osg::NodePath * pPickNodePath) {
    if (pPickNodePath && pPickNodePath->empty()) return;
    osgUtil::LineSegmentIntersector::Intersections intersections;
    bool intersected;
    if (pPickNodePath)  intersected = view.computeIntersections(state.getPointerX(), state.getPointerY(), *pPickNodePath, intersections);
    else                intersected = view.computeIntersections(state.getPointerX(), state.getPointerY(), intersections);
    if (intersected)
    {
        ASSERT(intersections.size() <= 1);
        if (intersections.size()>0) state.setPickPosition(intersections.begin()->getWorldIntersectPoint());

        //for(osgUtil::LineSegmentIntersector::Intersections::iterator hitr = intersections.begin();
        //  hitr != intersections.end();
        //  ++hitr)
        //{
        //}
    }
}

---