ViewportWidget.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of FRAPPER
research.animationsinstitut.de
sourceforge.net/projects/frapper

Copyright (c) 2008-2009 Filmakademie Baden-Wuerttemberg, Institute of Animation 

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; version 2.1 of the License.

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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
-----------------------------------------------------------------------------
*/


#ifndef VIEWPORTWIDGET_H
#define VIEWPORTWIDGET_H

#include "FrapperPrerequisites.h"
#include "InstanceCounterMacros.h"
#include "SceneModel.h"
#include "ViewingParameters.h"
#include <QtGui/QWidget>
#include <QtGui/QMouseEvent>
#include <QtGui/QMessageBox>
#include <QtGui/QRgb>
#include <QtGui/QColor>
#include <QtCore/QString>
#include <Ogre.h>
#if (OGRE_PLATFORM  == OGRE_PLATFORM_WIN32)
#include <windows.h>
#endif
#include <OgrePanelOverlayElement.h>
#include <OgreTextAreaOverlayElement.h>


#define VF_MAIN_VIEWPORT 0x1

#define VF_ORIENTATION_VIEWPORT 0x2


namespace Frapper {

class FRAPPER_GUI_EXPORT ViewportWidget : public QWidget
{

    Q_OBJECT
    ADD_INSTANCE_COUNTER

private: // static data

    static unsigned int s_viewportIndex;

        static Ogre::HighLevelGpuProgramPtr s_defaultVertexShader;

        static Ogre::HighLevelGpuProgramPtr s_defaultFragmentShader;

        static Ogre::HighLevelGpuProgramPtr s_defaultUVVertexShader;

        static Ogre::HighLevelGpuProgramPtr s_defaultTU0FragmentShader;
    
    static Ogre::MaterialPtr s_redMaterial;

    static Ogre::MaterialPtr s_greenMaterial;

    static Ogre::MaterialPtr s_blueMaterial;

    static Ogre::MaterialPtr s_grayMaterial;

    static Ogre::MaterialPtr s_blackMaterial;

    static Ogre::MaterialPtr s_defaultMaterial;

    static Ogre::MaterialPtr s_nullMaterial;

public: // constructors and destructors

    ViewportWidget ( QWidget *parent = 0, unsigned int stageIndex = 1, bool fullscreen = false, bool stereo = false, int width = 1024, int height = 768 );

    virtual ~ViewportWidget();

public: // functions

    virtual QPaintEngine * paintEngine () const;

    unsigned int getStageIndex ();

    void setStageIndex ( unsigned int stageIndex );

    void setViewMode ( bool viewMode );

    void frameSelectedObjects ();

    void setFog ( bool enabled, float density );

    QColor getFogColor ();

    void setFogColor ( const QColor &color );

    QColor getBackgroundColor ();

    void setBackgroundColor ( const QColor &color );

    void setFullscreen ( bool fullscreen, int width, int height );

    void getStereoParameters( float &rttWidth, float &rttHeight,
                              float &eyeDist, float &fOffsetMultiplier,
                              float &nearClip, float &farClip, float &fov, float &focalLength );

    void setStereoParameters( const unsigned int rttWidth, const unsigned int rttHeight,
                              const float eyeDist, const float fOffsetMultiplier,
                              const float nearClip, const float farClip, const float fov, const float focalLength );

    void setStereo ( bool enable );

    void setOverlayOnly ( bool enable );

    float getFps ();

    int getTriangleCount ();

    ViewingParameters * getViewingParameters ();

    void updateView ();

    Ogre::RenderWindow* getRenderWindow();

public slots: //

    void applyViewingParameters ( ViewingParameters *viewingParameters );

    void setImage ( unsigned int stageIndex, Ogre::TexturePtr image );

    void homeView ();

    void setWireframe ( bool wireframe );

    void setBackfaceCulling ( bool backfaceCulling );

    void toggleOrigin ();

    void toggleCenterPoint ();

    void toggleOrientationIndicator ();

    void toggleGrid ();
        void screenCapture ();

signals: //

    void objectSelected ( const QString &objectName, bool toggle );

    void viewChanged ( ViewingParameters *viewingParameters );

    void frameSelectedObjectsRequested ( ViewingParameters *viewingParameters );
    
    void renderingTriggered();

protected: // events

    virtual void resizeEvent ( QResizeEvent *event );

    virtual void paintEvent ( QPaintEvent *event );

    virtual void mousePressEvent ( QMouseEvent *event );

    virtual void mouseMoveEvent ( QMouseEvent *event );

    virtual void mouseReleaseEvent ( QMouseEvent *event );

    virtual void wheelEvent ( QWheelEvent *event );

private: // functions

    Ogre::String createUniqueName ( const QString &objectName );

        bool createdefaultShaders ();

        Ogre::HighLevelGpuProgramPtr compileShader ( const Ogre::String &code, Ogre::GpuProgramType type, const Ogre::String &nameSuffix );

    bool createRenderWindow ();

    void initializeResources ();

    void createViewportObjects ();

    void createOverlays ();

    void render ();

    Ogre::MaterialPtr createColorMaterial ( const Ogre::String &group, const Ogre::String &name, const Ogre::ColourValue &color, bool wireframe = false );

    void createAxes ( const QString &name, Ogre::SceneNode *parentNode, Ogre::uint32 visibilityFlags = VF_MAIN_VIEWPORT );

    void createGrid ( Ogre::SceneNode *parentNode );

    Ogre::SceneNode * getClickedSceneNode ( const QPointF &mousePosition );

protected: // data

    unsigned int m_stageIndex;

    bool m_showOverlays;

    bool m_fullscreen;

    bool m_stereo;

    float m_stereoEyeDist;
    float m_stereoFOffsetMultiplier;
    float m_stereoNearClip;
    float m_stereoFarClip;
    float m_stereoFov;
    float m_stereoFocalLength;
    unsigned int m_stereoRttWidth;
    unsigned int m_stereoRttHeight;

    int m_width;

    int m_height;

    // OGRE System Objects

    Ogre::RenderWindow *m_renderWindow;

    Ogre::SceneManager *m_sceneManager;

    Ogre::SceneNode *m_cameraSceneNode;
    
    Ogre::MaterialPtr m_imageMaterial;

    Ogre::Camera *m_camera;
    Ogre::Camera *m_camera0;
    Ogre::Camera *m_camera1;
    Ogre::Camera *m_camera2;
    Ogre::Camera *m_camera3;
    Ogre::Camera *m_camera4;

    QString m_cameraName;

    Ogre::Light *m_headLight;

    Ogre::CompositorInstance *m_stereoCompositor;

    Ogre::RenderTarget *m_stereoRenderTarget;

    Ogre::Viewport *m_viewport;
    Ogre::Viewport *m_stereoViewport0;
    Ogre::Viewport *m_stereoViewport1;
    Ogre::Viewport *m_stereoViewport2;
    Ogre::Viewport *m_stereoViewport3;
    Ogre::Viewport *m_stereoViewport4;

        Ogre::ColourValue m_backgroundColor;

        Ogre::ColourValue m_fogColor;

    Ogre::SceneNode *m_orientationIndicatorCameraSceneNode;

    Ogre::Camera *m_orientationIndicatorCamera;

    Ogre::Viewport *m_orientationIndicatorViewport;

    // Overlays

    Ogre::Overlay *m_labelOverlay;

    Ogre::Overlay *m_imageOverlay;

    Ogre::PanelOverlayElement *m_leftTopHudPanel;

    Ogre::TextAreaOverlayElement *m_leftTopHudTextArea;

    Ogre::PanelOverlayElement *m_imagePanel;

    // Scene Nodes

    Ogre::SceneNode *m_viewportObjectsSceneNode;

    Ogre::SceneNode *m_originSceneNode;

    Ogre::SceneNode *m_centerPointSceneNode;

    Ogre::SceneNode *m_orientationIndicatorSceneNode;

    Ogre::SceneNode *m_gridSceneNode;

    // Viewing

    bool m_viewMode;

    QPoint m_lastPosition;

    ViewingParameters *m_viewingParameters;

    // Display Flags

    bool m_wireframe;

    bool m_backfaceCulling;

    bool m_showOrigin;

    bool m_showCenterPoint;

    bool m_showOrientationIndicator;

    bool m_showGrid;

    bool m_overlayOnly;

    float m_dbgColor;

};

} // end namespace Frapper

#endif