C:/Documents and Settings/benesova/Plocha/FlowVis/vislab2/rendererWidget.h

Go to the documentation of this file.

#ifndef __RENDERER_WIDGET__
#define __RENDERER_WIDGET__

#include <queue>

#include <GL/glew.h>

#include <QtOpenGL/QGLWidget>
#include <QtGui/QColor>
#include <QtGui/QMessageBox>

#include <QtGui/QMouseEvent>
#include <QtGui/QWheelEvent>

#include "GLext.h"
#include <gl/glut.h>
#include <assert.h>
#include "logger.h"
#include "histogram.h"
#include "integration.h"

#include <Cg/cg.h>
#include <Cg/cgGL.h>

#include "FVF/FlowData.h"

#include "FlowGrid.h"
#include "reggrid.h"

#include "settings.h"
#include "streamline.h"

#include "shaderLoader.h"

using std::queue;

class RendererWidget : public QGLWidget
{
    Q_OBJECT
public:
    RendererWidget(QWidget *parent = 0);

    QSize minimumSizeHint() const;

        bool loadData(FlowData *stream);

        enum RenderingState
        {
                RS_NOTHING
        };

public slots:
        void changeSettings(Settings *settings);

signals:
        void newDataLoaded(Histogram *histogram);

protected:
        bool leftButtonHeld;

        unsigned int m_startingX;               
        unsigned int m_startingY;               

        //cml::vector3d m_oldTracball;  ///< DELETE

        bool m_dragging;                                
        bool m_moving;                                  

        void mouseMoveEvent(QMouseEvent *event);
        void mousePressEvent(QMouseEvent * event);
        void mouseReleaseEvent(QMouseEvent *event);

        void wheelEvent(QWheelEvent *event);

        //void createLuminanceTexture(unsigned int _width, unsigned int _height, unsigned int _depth, unsigned short *_data);
        //void createRGBTexture(unsigned int _width, unsigned int _height, unsigned int _depth, unsigned char *_data);

    void initializeGL();
    void paintGL();
    void resizeGL(int width, int height);

        
        GLuint BuildAdditionalTexture(int channelId);
        void BuildMainTexture();

        void LoadArrowTexture();

        void EnableBlending();
        void DisableBlending();

        static void PackVector(float min, float max, float x, float y, float z, unsigned char *result);
private:

        void DrawBackgroundImage();
        void DrawArrows();

        double GetNormalizedX(int x);
        double GetNormalizedY(int Y);

        cml::vector2f *GenerateSeeds(int noSeedsX, int noSeedsY);


        //void DrawStreamline(cml::vector2f seed, const string &integrationSettingName, IntegrationType integrationType);
        void DrawStreamline(Streamline *streamline);
        void DrawStreamlines(vector<Streamline *> &streamlines);

        Streamline *RendererWidget::ConstructStreamline(
                cml::vector2f seed,
                const string &integrationSettingName,
                IntegrationType integrationType
        );


        void RendererWidget::ConstructStreamlines(
                std::vector<Streamline *> &streamlines,
                IntegrationType integrationType
        );

        void RendererWidget::ConstructEvenlySpacedStreamline(
                Reggrid *regGrid,
                queue<cml::vector2f> &candidateList,
                float stepSize,
                float dSep,
                IntegrationType integrationType,
                Streamline **streamlines
        );

        void RendererWidget::ConstructEvenlySpacedStreamlines(
                std::vector<Streamline *> &streamlines,
                float dSep,
                float dTest,
                IntegrationType integrationType
        );

        std::vector<Streamline *> m_eulerStreamlines;
        std::vector<Streamline *> m_rkStreamlines;

        void checkForCgError(const char *situation);
        
        static const unsigned short int sizeLimit = 2000;
        
        bool dataLoaded;

        Settings *m_settings;

        FlowData *m_flowData;

        int m_velocityChannel;
        int m_xChannel;
        int m_yChannel;
        int m_zChannel;
        int m_firstAdditionalChannel;
        int m_secondAdditionalChannel;
        int m_geometryXChannel;
        int m_geometryYChannel;

        //PFNGLTEXIMAGE3DPROC glTexImage3D;

        //unsigned int m_luminanceTexture;      ///< luminance texture id
        //unsigned int m_rgbTexture;                    ///< rgb texture id
        //unsigned int textureName;

        int m_width;                                            
        int m_height;                                           

        GLuint m_velocityTexture;                       
        GLuint m_firstAdditionalTexture;
        GLuint m_secondAdditionalTexture;
        GLuint m_mainTexture;
        GLuint m_arrowTexture;

        float m_datasetWidth;
        float m_datasetHeight;

        //unsigned char *m_mainTextureLocal;
        FlowGrid m_flowGrid;

        const int m_mainTextureSize;
        const int m_velocityTextureSize;

        RenderingState m_renderingState;                


        ShaderLoader *m_shaderLoader;                   
        //ShaderProgram *m_sliceColoringProgram;        ///< how it should be done

        ShaderProgram *m_backgroundQuadProgram;
        ShaderProgram *m_arrowVertexProgram;
        ShaderProgram *m_arrowFragmentProgram;
};

#endif

---