coVRPlugin.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_PLUGIN_H
#define COVR_PLUGIN_H
 
#include <util/coExport.h>
#include <osg/Matrix>
#include <osg/Drawable>
#include <cover/coVRDynLib.h>
#include <cstdlib>
 
namespace osg
{
class Node;
class Group;
}
 
namespace vrui
{
class coMenuItem;
}
 
namespace covise
{
class Message;
class UdpMessage;
class DataHandle;
}
 
// use COVERPLUGIN(YourMainPluginClass) in your plugin implementation
#define COVERPLUGIN(Plugin)                                         \
    extern "C" PLUGINEXPORT opencover::coVRPlugin *coVRPluginInit() \
    {                                                               \
        opencover::coVRPlugin *p = new Plugin;                      \
        if (p)                                                      \
            p->setName(#Plugin);                                    \
        return p;                                                   \
    }
 
namespace opencover
{
class RenderObject;
class coInteractor;
class Url;
 
//
 
class COVEREXPORT coVRPlugin
{
    friend class coVRPluginList;
 
public:
    enum NotificationLevel {
        Info,
        Warning,
        Error,
        Fatal
    };
 
    coVRPlugin();
 
    virtual ~coVRPlugin();
 
    virtual bool init()
    {
        return true;
    }
    
    virtual bool init2()
    {
        return true;
    }
 
    virtual bool destroy()
    {
        return true;
    }
 
    const char *getName() const
    {
        return m_name.c_str();
    }
 
    void setName(const char *sn);
 
    virtual void notify(NotificationLevel level, const char *text)
    {
        (void)level;
        (void)text;
    }
 
    virtual void addNode(osg::Node *, const RenderObject * = NULL)
    {
    }
 
    virtual void removeNode(osg::Node *, bool isGroup, osg::Node *realNode)
    {
        (void)isGroup;
    }
 
    virtual void addObject(const RenderObject *container, osg::Group *parent,
            const RenderObject *geometry, const RenderObject *normals, const RenderObject *colors, const RenderObject *texture)
    {
        (void)container;
        (void)parent;
        (void)geometry;
        (void)normals;
        (void)colors;
        (void)texture;
    }
 
    virtual void removeObject(const char *objName, bool replaceFlag)
    {
        (void)objName;
        (void)replaceFlag;
    }
 
    virtual void newInteractor(const RenderObject *container, coInteractor *it)
    {
        (void)container;
        (void)it;
    }
 
    virtual bool requestInteraction(coInteractor *inter, osg::Node *triggerNode, bool isMouse)
    {
        (void)inter;
        (void)triggerNode;
        (void)isMouse;
        return false;
    }
 
    virtual void coviseError(const char *error)
    {
        (void)error;
    }
 
    virtual void guiToRenderMsg(const char *msg)
    {
        (void)(msg);
    };
 
    virtual bool update()
    {
        return false; // don't request that scene be re-rendered
    }
 
    virtual void preFrame()
    {
    }
 
    virtual void postFrame()
    {
    }
 
    virtual void preDraw(osg::RenderInfo &)
    {
    }
 
    virtual void preSwapBuffers(int /*windowNumber*/)
    {
    }
 
    virtual void clusterSyncDraw()
    {
    }
 
    virtual void postSwapBuffers(int /*windowNumber*/)
    {
    }
 
    virtual void param(const char *paramName, bool inMapLoading)
    {
        (void)paramName;
        (void)inMapLoading;
    }
 
    virtual void key(int type, int keySym, int mod)
    {
        (void)type;
        (void)keySym;
        (void)mod;
    }
 
    virtual void userEvent(int mod)
    {
        (void)mod;
    }
 
    // this function is called if a message arrives
    virtual void message(int toWhom, int type, int length, const void *data)
    {
        (void)toWhom;
        (void)type;
        (void)length;
        (void)data;
    }
    // this function is called if a UDPmessage arrives
    virtual void UDPmessage(covise::UdpMessage* msg)
    {
        (void)msg;
    }
 
 
    virtual void setTimestep(int t)
    {
        (void)t;
    }
 
    virtual void requestTimestep(int t)
    {
        commitTimestep(t);
    }
 
    virtual void getMatrix(int station, osg::Matrix &mat)
    {
        (void)station;
        (void)mat;
    }
 
    virtual unsigned int button(int station)
    {
        (void)station;
        return 0;
    }
 
    virtual int wheel(int station)
    {
        (void)station;
        return 0;
    }
 
    virtual void requestQuit(bool killSession)
    {
        (void)killSession;
    }
 
    virtual bool sendVisMessage(const covise::Message *msg)
    {
        (void)msg;
        return false;
    }
 
    virtual bool becomeCollaborativeMaster()
    {
        return false;
    }
 
    virtual std::string collaborativeSessionId() const
    {
        return "";
    }
 
 
    virtual covise::Message *waitForVisMessage(int messageType)
    {
        (void)messageType;
        return NULL;
    }
 
    virtual bool executeAll()
    {
        return false;
    }
 
    virtual void expandBoundingSphere(osg::BoundingSphere &bs)
    {
        (void)bs;
    }
 
    virtual bool windowCreate(int num)
    {
        (void)num;
        return false;
    }
 
    virtual void windowCheckEvents(int num)
    {
        (void)num;
    }
 
    virtual void windowUpdateContents(int num)
    {
        (void)num;
    }
 
    virtual void windowDestroy(int num)
    {
        (void)num;
    }
 
    virtual void windowFullScreen(int num, bool state)
    {
        (void)num;
        (void)state;
    }
 
    virtual bool updateViewer()
    {
        return false; // no update, no re-render required
    }
 
protected:
    void commitTimestep(int t);
 
private:
    void requestTimestepWrapper(int t);
 
    bool m_initDone;
    std::string m_name;
    CO_SHLIB_HANDLE handle;
    int m_outstandingTimestep;
};
}
#endif