coVRPluginSupport.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 OPEN_COVER_PLUGIN_SUPPORT
#define OPEN_COVER_PLUGIN_SUPPORT
 
 
#ifdef _WIN32
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x501 // This specifies WinXP or later - it is needed to access rawmouse from the user32.dll
#endif
#if (_MSC_VER >= 1300) && !(defined(MIDL_PASS) || defined(RC_INVOKED))
#define POINTER_64 __ptr64
#else
#define POINTER_64
#endif
#include <winsock2.h>
#include <io.h>
#ifndef PATH_MAX
#define PATH_MAX 512
#endif
#endif
 
#include <osg/Matrix>
#include <osg/Geode>
#include <osg/Drawable>
#include <osg/ClipNode>
#include <osg/MatrixTransform>
#include <osgViewer/GraphicsWindow>
#include <osg/BoundingBox>
 
#include <list>
#include <ostream>
 
#include <OpenVRUI/sginterface/vruiButtons.h>
 
#include "coVRPlugin.h"
#include "coVRMessageSender.h"
 
#include <net/message_types.h>
 
namespace opencover {
namespace ui {
class ButtonGroup;
class Menu;
class Manager;
class VruiView;
}
}
 
namespace covise {
class Message;
class UdpMessage;
}
 
namespace grmsg {
class coGRMsg;
}
 
#define MAX_NUMBER_JOYSTICKS 64
 
namespace osg
{
class MatrixTransform;
}
namespace osgText
{
class Font;
}
 
namespace vrui
{
class coUpdateManager;
class coMenu;
class coToolboxMenu;
class coRowMenu;
}
namespace vrml
{
class Player;
}
 
namespace covise
{
class TokenBuffer;
}
namespace opencover
{
class coVRPlugin;
class RenderObject;
class coInteractor;
class NotifyBuf;
struct Isect
{
    enum IntersectionBits
    {
        Collision = 1,
        Intersection = 2,
        Walk = 4,
        Touch = 8,
        Pick = 16,
        Visible = 32,
        NoMirror = 64,
        Left = 128,
        Right = 256,
        CastShadow = 512,
        ReceiveShadow = 1024,
        Update = 2048,
        OsgEarthSecondary = 0x80000000,
    };
 
private:
};
 
namespace Notify
{
enum NotificationLevel
{
    Debug,
    Info,
    Warning,
    Error,
    Fatal
};
}
 
class COVEREXPORT coPointerButton
{
    friend class coVRPluginSupport;
    friend class coVRMSController;
 
public:
    coPointerButton(const std::string &name);
    ~coPointerButton();
    unsigned int getState() const;
    unsigned int oldState() const;
    unsigned int wasPressed(unsigned int buttonMask=vrui::vruiButtons::ALL_BUTTONS) const;
    unsigned int wasReleased(unsigned int buttonMask=vrui::vruiButtons::ALL_BUTTONS) const;
    bool notPressed() const;
    int getWheel(size_t idx=0) const;
    void setWheel(size_t idx, int count);
    const std::string &name() const;
 
private:
    void setState(unsigned int);
 
    unsigned int buttonStatus = 0;
    unsigned int lastStatus = 0;
    int wheelCount[2]={0,0};
    std::string m_name;
};
 
class COVEREXPORT coVRPluginSupport : public opencover::coVRMessageSender
{
    friend class OpenCOVER;
    friend class fasi;
    friend class fasi2;
    friend class mopla;
    friend class coVRMSController;
    friend class coIntersection;
 
public:
 
    bool debugLevel(int level) const;
    void initUI();
    // show a message to the user
    std::ostream &notify(Notify::NotificationLevel level=Notify::Info) const;
    std::ostream &notify(Notify::NotificationLevel level, const char *format, ...) const
#ifdef __GNUC__
        __attribute__((format(printf, 3, 4)))
#endif
        ;
 
    // OpenGL clipping
    enum
    {
        MAX_NUM_CLIP_PLANES = 6
    };
 
    int getNumClipPlanes();
 
    osg::ClipPlane *getClipPlane(int num)
    {
        return clipPlanes[num].get();
    }
 
    void preparePluginUnload();
 
    bool isClippingOn() const;
 
    int getActiveClippingPlane() const;
 
    void setActiveClippingPlane(int plane);
 
    // access to scene graph nodes and transformations
 
    osg::Group *getScene() const;
 
    osg::ClipNode *getObjectsRoot() const;
 
    // (in VRSceneGraph handTransform)
    osg::MatrixTransform *getPointer() const;
 
    const osg::Matrix &getPointerMat() const;
    //       void setPointerMat(osg::Matrix);
 
    const osg::Matrix &getMouseMat() const;
 
    const osg::Matrix &getRelativeMat() const;
 
    osg::MatrixTransform *getObjectsXform() const;
 
    const osg::Matrix &getXformMat() const;
 
    void setXformMat(const osg::Matrix &mat);
 
    osg::MatrixTransform *getObjectsScale() const;
 
    void setScale(float s);
 
    float getScale() const;
 
 
    const osg::Matrix &getBaseMat() const
    {
        return baseMatrix;
    }
 
 
    const osg::Matrix &getInvBaseMat() const;
 
    void watchFileDescriptor(int fd);
    void unwatchFileDescriptor(int fd);
 
    vrui::coUpdateManager *getUpdateManager() const;
 
    float getSceneSize() const;
 
    bool isHighQuality() const;
 
    bool isVRBconnected();
 
    bool sendVrbMessage(const covise::MessageBase *msg) const;
 
    // tracker data
 
    const osg::Matrix &getViewerMat() const;
 
    void setNodesIsectable(osg::Node *n, bool isect);
 
    coPointerButton *getPointerButton() const;
 
    coPointerButton *getMouseButton() const;
 
    coPointerButton *getRelativeButton() const;
 
    vrui::coMenu *getMenu();
 
    osg::Group *getMenuGroup() const;
 
    // interfacing with plugins
 
    coVRPlugin *addPlugin(const char *name);
 
    coVRPlugin *getPlugin(const char *name);
 
    void removePlugin(coVRPlugin *);
 
    int removePlugin(const char *name);
 
    void addedNode(osg::Node *node, coVRPlugin *myPlugin);
 
 
    bool removeNode(osg::Node *node, bool isGroup = false);
 
    void sendMessage(coVRPlugin *sender, int toWhom, int type, int len, const void *buf);
 
    void sendMessage(coVRPlugin *sender, const char *destination, int type, int len, const void *buf, bool localonly = false);
 
    bool grabKeyboard(coVRPlugin *);
 
    void releaseKeyboard(coVRPlugin *);
 
    bool isKeyboardGrabbed();
 
    bool grabViewer(coVRPlugin *);
    void releaseViewer(coVRPlugin *);
    bool isViewerGrabbed() const;
 
    void protectScenegraph();
 
    double frameTime() const;
 
    double frameDuration() const;
 
    double frameRealTime() const;
 
    static double currentTime();
 
    osgViewer::GraphicsWindow::MouseCursor getCurrentCursor() const;
 
    void setCurrentCursor(osgViewer::GraphicsWindow::MouseCursor type);
 
    void setCursorVisible(bool visible);
 
    osg::Node *getIntersectedNode() const;
 
    const osg::NodePath &getIntersectedNodePath() const;
 
    const osg::Vec3 &getIntersectionHitPointWorld() const;
 
    const osg::Vec3 &getIntersectionHitPointWorldNormal() const;
 
    osg::Matrix updateInteractorTransform(osg::Matrix mat, bool usePointer) const;
 
    /*********************************************************************/
    // do not use anything beyond this line
 
    // deprecated, use coInteraction with high priority instead
    // returns true if another plugin locked the pointer
    int isPointerLocked();
 
    // old COVISE Messages
    int sendBinMessage(const char *keyword, const char *data, int len);
    // update frametime
    void updateTime();
    // update matrices
    void update();
 
    void personSwitched(size_t personNumber);
 
    ui::Manager *ui = nullptr;
    ui::Menu *fileMenu = nullptr;
    ui::Menu *viewOptionsMenu = nullptr;
    ui::Menu *visMenu = nullptr;
    ui::ButtonGroup *navGroup() const;
    ui::VruiView *vruiView = nullptr;
 
    osg::Matrix envCorrectMat;
    osg::Matrix invEnvCorrectMat;
 
    int registerPlayer(vrml::Player *player);
    int unregisterPlayer(vrml::Player *player);
    vrml::Player *usePlayer(void (*playerUnavailableCB)());
    int unusePlayer(void (*playerUnavailableCB)());
 
    int numJoysticks;
    unsigned char number_buttons[MAX_NUMBER_JOYSTICKS];
    int *buttons[MAX_NUMBER_JOYSTICKS];
    unsigned char number_axes[MAX_NUMBER_JOYSTICKS];
    float *axes[MAX_NUMBER_JOYSTICKS];
    unsigned char number_sliders[MAX_NUMBER_JOYSTICKS];
    float *sliders[MAX_NUMBER_JOYSTICKS];
    unsigned char number_POVs[MAX_NUMBER_JOYSTICKS];
    float *POVs[MAX_NUMBER_JOYSTICKS];
 
    osg::ref_ptr<osg::ColorMask> getNoFrameBuffer()
    {
        return NoFrameBuffer;
    }
 
    // utility
    float getSqrDistance(osg::Node *n, osg::Vec3 &p, osg::MatrixTransform **path, int pathLength) const;
 
    osg::Matrix *getWorldCoords(osg::Node *node) const;
    osg::Vec3 frontScreenCenter; 
    float frontHorizontalSize; 
    float frontVerticalSize; 
    int frontWindowHorizontalSize; 
    int frontWindowVerticalSize; 
 
    float getInteractorScale(osg::Vec3 &pos); // pos in World coordinates
 
    float getViewerScreenDistance();
 
    osg::BoundingBox getBBox(osg::Node *node) const;
 
    //restrict interactors to visible scene
    bool restrictOn() const;
 
 
    enum MessageDestinations
    {
        TO_ALL,
        TO_ALL_OTHERS,
        TO_SAME,
        TO_SAME_OTHERS,
        VRML_EVENT, // Internal, do not use!!
        NUM_TYPES
    };
 
    vrui::coToolboxMenu *getToolBar(bool create = false);
    void setToolBar(vrui::coToolboxMenu *tb);
 
    void setFrameTime(double ft);
 
    void setRenderStrategy(osg::Drawable *draw, bool dynamic=false);
    opencover::coVRMessageSender *getSender();
    bool sendGrMessage(const grmsg::coGRMsg &grmsg, int msgType = covise::COVISE_MESSAGE_UI) const;
private:
    void setFrameRealTime(double ft);
 
    float scaleFactor; 
    float viewerDist; 
    osg::Vec3 eyeToScreen; 
 
    osg::ref_ptr<osg::ColorMask> NoFrameBuffer;
 
    osg::ref_ptr<osg::ClipPlane> clipPlanes[MAX_NUM_CLIP_PLANES];
 
    mutable vrui::coUpdateManager *updateManager;
 
    mutable int invCalculated;
    osg::Matrix handMat;
    bool wasHandValid = false;
    osg::Matrix baseMatrix;
    mutable osg::Matrix invBaseMatrix;
    double lastFrameStartTime;
    double frameStartTime, frameStartRealTime;
    osgViewer::GraphicsWindow::MouseCursor currentCursor;
    bool cursorVisible = true;
    vrml::Player *player = nullptr;
    std::set<void (*)()> playerUseList;
 
    int activeClippingPlane;
 
    osg::ref_ptr<osg::Geode> intersectedNode;
    osg::ref_ptr<osg::Drawable> intersectedDrawable;
    //osg::ref_ptr<osg::NodePath> intersectedNodePath;
    osg::NodePath intersectedNodePath;
    osg::Vec3 intersectionHitPointWorld;
    osg::Vec3 intersectionHitPointWorldNormal;
    osg::Vec3 intersectionHitPointLocal;
    osg::Vec3 intersectionHitPointLocalNormal;
    osg::ref_ptr<osg::RefMatrix> intersectionMatrix;
 
    mutable coPointerButton *pointerButton = nullptr;
    mutable coPointerButton *mouseButton = nullptr;
    mutable coPointerButton *relativeButton = nullptr;
    vrui::coToolboxMenu *m_toolBar = nullptr;
    vrui::coMenu *m_vruiMenu = nullptr;
    double interactorScale = 1.;
 
    int numClipPlanes;
 
    coVRPluginSupport();
    ~coVRPluginSupport();
 
    std::vector<std::ostream *> m_notifyStream;
    std::vector<NotifyBuf *> m_notifyBuf;
};
 
COVEREXPORT covise::TokenBuffer &operator<<(covise::TokenBuffer &buffer, const osg::Matrixd &matrix);
COVEREXPORT covise::TokenBuffer &operator>>(covise::TokenBuffer &buffer, osg::Matrixd &matrix);
 
COVEREXPORT covise::TokenBuffer &operator<<(covise::TokenBuffer &buffer, const osg::Vec3f &vec);
COVEREXPORT covise::TokenBuffer &operator>>(covise::TokenBuffer &buffer, osg::Vec3f &vec);
 
//============================================================================
// Useful inline Function Templates
//============================================================================
 
template <class C>
inline C coClamp(const C a, const C left, const C right)
{
    if (a < left)
        return left;
    if (a > right)
        return right;
    return a;
}
 
extern COVEREXPORT coVRPluginSupport *cover;
}
#endif