coVRNavigationManager.h

Go to the documentation of this file.

/* This file is part of COVISE.
 
   You can use it under the terms of the GNU Lesser General Public License
   version 2.1 or later, see lgpl-2.1.txt.
 
 * License: LGPL 2+ */
 
#ifndef COVR_NAVIGATION_MANAGER_H
#define COVR_NAVIGATION_MANAGER_H
 
#include <util/common.h>
 
#include "ui/Owner.h"
namespace opencover {
namespace ui {
class Group;
class Menu;
class Action;
class ButtonGroup;
class Button;
class Slider;
}
}
 
#include <osg/Vec3>
#include <osg/Matrix>
#include <osg/MatrixTransform>
#include <osg/Geometry>
 
namespace vrui
{
class coNavInteraction;
class coMouseButtonInteraction;
class coRelativeInputInteraction;
class coButtonMenuItem;
class coRowMenu;
}
namespace opencover
{
class coMeasurement;
class coVRLabel;
class coVRPlugin;
 
class COVEREXPORT coVRNavigationProvider
{
public:
    coVRNavigationProvider(const std::string name, coVRPlugin* plugin);
    virtual ~coVRNavigationProvider();
    coVRPlugin *plugin;
    ui::Button* navMenuButton = nullptr;
    std::string getName() { return name; };
    virtual void setEnabled(bool enabled);
    bool isEnabled() { return enabled; };
    int ID;
private:
    std::string name;
    bool enabled=false;
};
 
class COVEREXPORT coVRNavigationManager: public ui::Owner
{
    static coVRNavigationManager *s_instance;
    coVRNavigationManager();
 
public:
    enum NavMode
    {
        NavOther=-1,
        NavNone,
        XForm,
        Scale,
        Fly,
        Glide,
        Walk,
        ShowName,
        XFormRotate,
        XFormTranslate,
        TraverseInteractors,
        Menu,
        Measure,
        Select,
        SelectInteract,
        NumNavModes // keep last
    };
 
    float AnalogX, AnalogY;
 
    ~coVRNavigationManager();
    void updatePerson();
 
    static coVRNavigationManager *instance();
 
    // process key events
    bool keyEvent(int type, int keySym, int mod);
 
    void doWalkMoveToFloor();
    void processHotKeys(int keymask);
    void adjustFloorHeight();
    bool getCollision()
    {
        return collision;
    }
 
    void update();
    void setMenuMode(bool state);
 
    void updateHandMat(osg::Matrix &mat);
    void setHandType(int pt);
    void setNavMode(NavMode mode, bool updateGroup=true);
    void setNavMode(std::string navMode);
    NavMode getMode()
    {
        return navMode;
    }
    ui::ButtonGroup *navGroup() const;
    bool isNavigationEnabled()
    {
        return navMode != NavNone;
    }
    bool mouseNav()
    {
        return doMouseNav;
    }
    bool isViewerPosRotationEnabled()
    {
        return isViewerPosRotation;
    }
    void enableViewerPosRotation(bool b)
    {
        isViewerPosRotation = b;
    }
 
    void saveCurrentBaseMatAsOldBaseMat();
    bool avoidCollision(osg::Vec3 &glideVec); // returns true if collision occurred
 
    void wasJumping();
    float getDriveSpeed();
    void setDriveSpeed(float speed);
    bool isSnapping() const;
    bool isDegreeSnapping() const;
    float snappingDegrees() const;
    void enableSnapping(bool enable);
    void enableDegreeSnapping(bool enable, float degree);
    bool restrictOn() const;
 
    void setStepSize(float stepsize);
    float getStepSize() const;
    void doGuiScale(float scale);
    void doGuiRotate(float x, float y, float z);
    void doGuiTranslate(float x, float y, float z);
 
    int readConfigFile();
 
    void toggleShowName(bool state);
    void toggleInteractors(bool state);
    void toggleCollide(bool state);
 
    void startXform();
    void doXform();
    void stopXform();
    void startScale();
    void doScale();
    void stopScale();
    void startWalk();
    void doWalk();
    void stopWalk();
    void startDrive();
    void doDrive();
    void stopDrive();
    void startFly();
    void doFly();
    void stopFly();
    void doMouseFly();
    void doMouseXform();
    void doMouseScale();
    void doMouseScale(float);
    void doMouseWalk();
    void stopMouseNav();
    void startMouseNav();
    void startShowName();
    void doShowName();
    void stopShowName();
    void startMeasure();
    void doMeasure();
    void stopMeasure();
 
    void toggleSelectInteract(bool state);
    void startSelectInteract();
    void doSelectInteract();
    void stopSelectInteract(bool mouse);
 
 
    void doXformRotate();
    void doXformTranslate();
 
    void highlightSelectedNode(osg::Node *selectedNode);
    double speedFactor(double delta) const;
    osg::Vec3 applySpeedFactor(osg::Vec3 vec) const;
 
    void getHandWorldPosition(float *, float *, float *);
 
    float getPhi(float relCoord1, float width1);
 
    float getPhiZHori(float x2, float x1, float y2, float widthY, float widthX);
    float getPhiZVerti(float y2, float y1, float x2, float widthX, float widthY);
    void makeRotate(float heading, float pitch, float roll, int headingBool, int pitchBool, int rollBool);
 
    void disableRotationPoint()
    {
        rotationPoint = false;
    }
    void disableRotationAxis()
    {
        rotationAxis = false;
    }
    bool getRotationPointActive()
    {
        return rotationPoint;
    }
    bool getRotationAxisAcitve()
    {
        return rotationAxis;
    }
    void setRotationPoint(float x, float y, float z, float size = 1.f);
    void setRotationPointVisible(bool visible);
    osg::Vec3 getRotationPoint()
    {
        return rotPointVec;
    }
    void setRotationAxis(float x, float y, float z);
    void setTranslateFactor(float f)
    {
        guiTranslateFactor = f;
    }
    void registerNavigationProvider(coVRNavigationProvider*);
    void unregisterNavigationProvider(coVRNavigationProvider*);
 
 
private:
    bool doMouseNav;
    int mouseNavButtonRotate, mouseNavButtonScale, mouseNavButtonTranslate;
    bool wiiNav;
    double menuButtonStartTime;
    double menuButtonQuitInterval;
 
    bool collision;
    bool ignoreCollision;
    NavMode navMode;
    NavMode oldNavMode;
    std::list<coVRNavigationProvider*> navigationProviders;
 
    /* until button is released */
 
    bool shiftEnabled, shiftMouseNav;
    bool isViewerPosRotation; // mouse rotate around current viewer position
    osg::Matrix mat0;
 
    osg::Matrix invBaseMatrix;
    osg::Matrix oldInvBaseMatrix;
    osg::Node *oldFloorNode = nullptr;
    osg::Matrix oldFloorMatrix;
    osg::NodePath oldNodePath;
 
 
    float currentVelocity;
 
    osg::Matrix old_mat, old_dcs_mat;
    osg::Matrix old_xform_mat;
    osg::Matrix handMat;
    osg::Vec3 startHandPos; //we need the start value for ongoing interaction
    osg::Vec3 startHandDir; //we need the start value for ongoing interaction
    osg::Vec3 handPos, oldHandPos;
    osg::Vec3 handDir, oldHandDir;
    osg::Vec3 transformVec;
    osg::Vec3 rotationVec;
    bool rotationPoint;
    bool rotationPointVisible;
    bool rotationAxis;
    float guiTranslateFactor;
 
    float actScaleFactor; //fuer die Skalieroption, Initialisierung in der naechsten ifSchleife
    float mx, my;
    float x0, y0, relx0, rely0;
    float oldRotx, newRotx, oldRoty, newRoty;
    float modifiedVSize, modifiedHSize, yValViewer, yValObject;
    float transXRel, transYRel, transZRel;
    float originX, originY;
 
    int wiiFlag;
 
    osg::Node *oldSelectedNode_;
 
    float oldDcsScaleFactor;
 
    osg::Vec3 currentLeftPos; // in WC
    osg::Vec3 currentRightPos;
    osg::Vec3 oldLeftPos; // in WC
    osg::Vec3 oldRightPos;
    float collisionDist;
 
    int jsZeroPosX, jsZeroPosY, jsOffsetX, jsOffsetY, jsXmax, jsYmax, jsXmin, jsYmin;
    bool jsEnabled;
 
    bool visensoJoystick;
    bool joystickActive;
 
    vrui::coNavInteraction *interactionA = nullptr; 
    vrui::coNavInteraction *interactionB = nullptr; 
    vrui::coNavInteraction *interactionC = nullptr; 
    vrui::coNavInteraction *interactionMenu = nullptr; 
    vrui::coNavInteraction *interactionShortcut = nullptr; 
    vrui::coMouseButtonInteraction *interactionMA = nullptr; 
    vrui::coMouseButtonInteraction *interactionMB = nullptr; 
    vrui::coMouseButtonInteraction *interactionMC = nullptr; 
    vrui::coRelativeInputInteraction *interactionRel = nullptr; 
 
    float navExp;
 
    float syncInterval;
 
    float stepSize;
 
    float driveSpeed;
 
    void init();
    bool jump; // set to true if a jump has been performed to disable collision detection
    bool snapping;
    bool snappingD;
    float snapDegrees;
    bool m_restrict = false;
    float rotationSpeed;
    bool turntable;
    bool animationWasRunning=false;
 
    bool showGeodeName_;
    osg::Node *oldShowNamesNode_ = nullptr;
    coVRLabel *nameLabel_;
    vrui::coRowMenu *nameMenu_;
    vrui::coButtonMenuItem *nameButton_;
    ui::Menu *navMenu_ = nullptr;
    ui::Action *m_viewAll=nullptr, *m_resetView=nullptr;
    ui::Group *navModes_ = nullptr;
    ui::ButtonGroup *navGroup_ = nullptr;
    ui::Button *noNavButton_=nullptr;
    ui::Button *xformButton_=nullptr, *scaleButton_=nullptr, *flyButton_=nullptr, *walkButton_=nullptr, *driveButton_=nullptr;
    ui::Button *xformRotButton_=nullptr, *xformTransButton_=nullptr, *selectButton_=nullptr, *showNameButton_=nullptr;
    ui::Button *selectInteractButton_=nullptr;
    ui::Button *measureButton_=nullptr, *traverseInteractorButton_=nullptr;
    ui::Button *collisionButton_=nullptr, *snapButton_=nullptr;
    ui::Slider *driveSpeedSlider_=nullptr;
    ui::Action *scaleUpAction_=nullptr, *scaleDownAction_=nullptr;
    ui::Slider *scaleSlider_=nullptr;
    ui::Action *centerViewButton = nullptr;
    ui::Action *printObjectTransform = nullptr;
    osg::Vec3 rotPointVec;
    osg::ref_ptr<osg::MatrixTransform> rotPoint;
 
    std::vector<coMeasurement *> measurements;
 
    void initInteractionDevice();
    void initAxis();
    void initHandDeviceGeometry();
    void initCollMenu();
    void initMatrices();
    void initMenu();
    void initShowName();
    void initMeasure();
    
    osg::Vec3 getCenter() const;
    void centerView();
    osg::Vec3 mouseNavCenter;
};
}
#endif