Vizkit3DWidget.hpp

Go to the documentation of this file.

#ifndef __VIZKIT_QVIZKITWIDGET__
#define __VIZKIT_QVIZKITWIDGET__

#include "Vizkit3DPlugin.hpp"

#include <QtDesigner/QDesignerExportWidget>
#include <QVector3D>
#include <QTimer>

// disable tons of waringins in osg
// this is only valid for the rest of this 
// file
#if defined(__clang__)
    #pragma clang system_header
#elif defined(__GNUC__) || defined(__GNUG__)
    #pragma GCC system_header
#endif
#include <osgViewer/CompositeViewer>
#include <osgGA/CameraManipulator>

namespace osgQt { class GraphicsWindowQt;}
namespace vizkit3d
{
    class EnvPluginBase;
    class Vizkit3DWidget;

    enum CAMERA_MANIPULATORS
    {
        DEFAULT_MANIPULATOR,
        FIRST_PERSON_MANIPULATOR,
        FLIGHT_MANIPULATOR,
        ORBIT_MANIPULATOR,
        TERRAIN_MANIPULATOR,
        TRACKBALL_MANIPULATOR,
        MULTI_TOUCH_TRACKBALL_MANIPULATOR,
        NODE_TRACKER_MANIPULATOR,
        NO_MANIPULATOR
    };

    // configuration class
    class Vizkit3DConfig :public QObject
    {
        Q_OBJECT

        private:
            Q_PROPERTY( bool axes READ isAxes WRITE setAxes)
            Q_PROPERTY( bool axes_labels READ isAxesLabels WRITE setAxesLabels)
            Q_PROPERTY( QColor background READ getBackgroundColor WRITE setBackgroundColor)
            Q_PROPERTY( QStringList frame READ getVisualizationFrames WRITE setVisualizationFrame)
            Q_PROPERTY( bool environment READ isEnvironmentPluginEnabled WRITE setEnvironmentPluginEnabled)
            Q_PROPERTY( bool transformer READ isTransformer WRITE setTransformer)
            Q_ENUMS( CAMERA_MANIPULATORS )
            Q_PROPERTY( QStringList manipulator READ getAvailableCameraManipulators WRITE setCameraManipulator )
            Q_PROPERTY( double transformerTextSize READ getTransformerTextSize WRITE setTransformerTextSize );

        public:
            Vizkit3DConfig(Vizkit3DWidget *parent);
            Vizkit3DWidget* getWidget() const;

        signals:
            void propertyChanged(QString);

        public slots:
            bool isAxes() const;
            void setAxes(bool value);

            bool isAxesLabels() const;
            void setAxesLabels(bool value);
            QStringList getVisualizationFrames() const;
            void setVisualizationFrame(const QStringList &frames);

            bool isTransformer() const;
            void setTransformer(bool value);

            bool isEnvironmentPluginEnabled() const;
            void setEnvironmentPluginEnabled(bool enabled);

            float getTransformerTextSize() const;
            void setTransformerTextSize(float value);

            QColor getBackgroundColor()const;
            void setBackgroundColor(QColor color);

            static QString manipulatorIDToName(CAMERA_MANIPULATORS id);
            static CAMERA_MANIPULATORS manipulatorNameToID(QString const& name);
            
            void setCameraManipulator(QStringList const& manipulators);
            QStringList getAvailableCameraManipulators() const;
    };

    class QDESIGNER_WIDGET_EXPORT Vizkit3DWidget : public QWidget, public osgViewer::CompositeViewer
    {
        Q_OBJECT
        public:
            static osg::Vec3d const DEFAULT_EYE;
            static osg::Vec3d const DEFAULT_CENTER;
            static osg::Vec3d const DEFAULT_UP;

            friend class VizPluginBase;
            Vizkit3DWidget(QWidget* parent = 0,const QString &world_name = "world_osg",bool auto_update = true);

            ~Vizkit3DWidget();

            osg::Group* getRootNode() const;
            void setTrackedNode(osg::Node* node, QString tracked_object_name);
            void setTrackedNode(vizkit3d::VizPluginBase* plugin);

            QSize sizeHint() const;

            void setCameraManipulator(osg::ref_ptr<osgGA::CameraManipulator> manipulator, bool resetToDefaultHome = false);

        public slots:
            void addPlugin(QObject* plugin, QObject* parent = NULL);
            void removePlugin(QObject* plugin);

            QString getRootVisualizationFrame() const;

            void setVisualizationFrame(const QString &frame, bool update)
            { return setVisualizationFrame(frame); }

            void setVisualizationFrame(const QString &frame);

            void setRootFrame(QString frame);

            // we have to use a pointer here otherwise qt ruby is crashing
            QStringList* getVisualizationFramesRuby() const;
            QStringList getVisualizationFrames() const;
            QString getVisualizationFrame() const;

            void setPluginDataFrame(const QString &frame, QObject *plugin);
            QString getPluginDataFrame(QObject *plugin)const;

            void setTransformation(const QString &source_frame,const QString &target_frame,
                    const QVector3D &position, const QQuaternion &orientation);
            void getTransformation(const QString &source_frame,const QString &target_frame, QVector3D &position, QQuaternion &orientation)const;
            QString getWorldName()const;

            void setCameraLookAt(double x, double y, double z);
            void setCameraEye(double x, double y, double z);
            void setCameraUp(double x, double y, double z);
            void getCameraView(QVector3D& eye, QVector3D& lookAt, QVector3D& up);

            void setSmallFeatureCullingPixelSize(float val);

            QColor getBackgroundColor()const;
            void setBackgroundColor(QColor color);

            void collapsePropertyBrowser();
            QWidget* getPropertyWidget()const;

            bool isTransformer() const;
            void setTransformer(bool value);
            float getTransformerTextSize() const;
            void setTransformerTextSize(float value);
            bool isAxes() const;
            void setAxes(bool value);

            bool isAxesLabels() const;
            void setAxesLabels(bool value);
            void enableGrabbing();
            void disableGrabbing();
            QImage grab();

            QString findPluginPath(QString plugin_name);
            QString findLibPath(QString lib_name);
            QObject* loadPlugin(QString lib_name,QString plugin_name);
            QStringList* getAvailablePlugins();

            void setCameraManipulator(QString manipulator, bool resetToDefaultHome = false);
            void setCameraManipulator(CAMERA_MANIPULATORS manipulator, bool resetToDefaultHome = false);
            QString getCameraManipulatorName() const;
            CAMERA_MANIPULATORS getCameraManipulator() const;

            void setEnvironmentPlugin(QObject* plugin);

            void setEnvironmentPluginEnabled(bool enabled);

            bool isEnvironmentPluginEnabled() const;

            void clearEnvironmentPlugin();

        signals:
            void addPlugins(QObject* plugin,QObject* parent);
            void removePlugins(QObject* plugin);
            void propertyChanged(QString propertyName);

        protected:
            virtual void paintEvent( QPaintEvent* event );

        private slots:
            void setPluginDataFrameIntern(const QString &frame, QObject *plugin);
            void addPluginIntern(QObject* plugin,QObject *parent=NULL);
            void removePluginIntern(QObject* plugin);
            void pluginActivityChanged(bool enabled);
            void pluginChildrenChanged();
            void addProperties(QObject* plugin,QObject *parent=NULL);

        private:
            // Helper method for setPluginEnabled
            void enableEnvironmentPlugin();
            // Helper method for setPluginEnabled
            void disableEnvironmentPlugin();
            void changeCameraView(const osg::Vec3* lookAtPos, const osg::Vec3* eyePos, const osg::Vec3* upVector);
            void setPluginEnabled(QObject* plugin, bool enabled);
            QObject* loadLib(QString file_path);

            void registerDataHandler(VizPluginBase *viz);
            void deregisterDataHandler(VizPluginBase *viz);
            void enableDataHandler(VizPluginBase *viz);
            void disableDataHandler(VizPluginBase *viz);
            osg::Group *createSceneGraph(const QString &world_name);

            QWidget* addViewWidget( osgQt::GraphicsWindowQt* gw, ::osg::Node* scene );
            osgQt::GraphicsWindowQt* createGraphicsWindow( int x, int y, int w, int h, const std::string& name="", bool windowDecoration=false );

        private:
            //holds the scene
            osg::ref_ptr<osg::Group> root;

            // The name of a frame that should be directly attached to osg_world
            QString root_frame;

            //the plugin currently used as environment plugin
            EnvPluginBase* env_plugin;

            struct VizPluginInfo {
                osg::ref_ptr<osg::Group> osg_group_ptr;
                QWeakPointer<VizPluginBase> weak_ptr;
                
                VizPluginInfo(VizPluginBase* plugin_ptr_, osg::ref_ptr<osg::Group> osg_group_ptr_)
                  : osg_group_ptr(osg_group_ptr_),
                    weak_ptr(plugin_ptr_) 
                {
                }
            };
            typedef std::map<VizPluginBase*,  VizPluginInfo> PluginMap;
            PluginMap plugins;

            QTimer _timer;

            QString current_frame;

            QString tracked_object_name;

            osg::ref_ptr<osg::Image> grabImage;

            CAMERA_MANIPULATORS last_manipulator;
            CAMERA_MANIPULATORS current_manipulator;

            osg::ref_ptr<osg::Referenced> captureHandler;
            osg::ref_ptr<osg::Referenced> captureOperation;
    };
}
#endif