FlowVis/RenderWidget.h

#ifndef RENDERWIDGET_H
#define RENDERWIDGET_H

#include "commonGL.h"
//#include <gl.h>
#include <QGLWidget>
#include <vector>
#include <queue>
#include "Framework/FlowData.h"
#include "shader.h"
#include "Streamline.h"
#include "LayerRenderable.h"

using std::vector;
using std::queue;


class RenderWidget : public QGLWidget
{
        Q_OBJECT

public:
        RenderWidget(QWidget *parent=NULL);
        ~RenderWidget();

        int heightForWidth(int w) const;

protected:

        void initializeGL();

        void resizeGL(int w, int h);

        void paintGL();


private:

        const double PI;

        float* xdata;
        float* ydata;

        LayerRenderable* testLayer;
        LayerRenderable* testarrowLayer;
        GLuint testTransferTexture;
        int textureSize;
        int textureWidth;
        int textureHeight;
        int arrowCount;

        QVector<LayerRenderable*> layers;
        QVector<Shader*> shaders;
        GLuint* textures;
        int channelCount;
        GLuint* disp_lists;
        Shader *simple;
        Shader *arrows;
        Shader *slines;
        Shader *sltexture;

        float arrowSize;
        float d_sep_val;
        float d_sep;
        float d_test_val;
        float d_test;
        float dt;
        int sl_num_samples;
        vector<Streamline*> streamlines;

        int integration_mode;
        static const int EULER = 0;
        static const int RK2 = 1;
        static const int RK4 = 2;

        int streamline_mode;
        static const int NORMAL = 0;
        static const int TAPERING = 1;
        static const int GLYPH = 2;
        static const int TEXTURE = 3;

        void initArrows(int n, float aspect);

        void generateNormalStreamlineList();

        void generateTaperingStreamlineList();

        void generateGlyphStreamlineList();

        void generateTextureStreamlineList();

        float getSLIntensityForRank(int rank, int function_type);

        void initGlew();

        void loadData(std::string filename);

        void loadChannels(FlowData* dataset);

        void computeStreamlines();

        Streamline* calculateStreamline(vec3* seed, int gridWidth, int gridHeight, vector<vec3>** grid);

        void gridAddAt(vector<vec3>* grid, int gridwidth, int gridheight, vec3 pos);

        bool gridAroundOkay(vector<vec3>* grid, int gridwidth, int gridheight, vec3 pos, queue<vec3>* lastones);

        float minGridDistance(vector<vec3>* grid, int gridwidth, int gridheight, vec3 pos, queue<vec3>* lastones);

        bool distanceOkay(vec3 from, vec3 to);

        vec3 getNextEulerPoint(vec3 sample_point, bool backward);

        vec3 getNextRungeKutta2Point(vec3 sample_point, bool backward);

        vec3 getNextRungeKutta4Point(vec3 sample_point, bool backward);

        void printGLError();
        
signals:

        void dataLoaded(int channels);

        void emitSettingValues(int value, int slider);

public slots:
        void loadDataFile();

        void layerChannelChanged(int channel, int layer);

        void layerTypeChanged(int type, int layer);

        void layerTransferImageChanged(const QImage& image, int layer);

        void layerAdd(int layer);

        void layerMove(int layer,int newPos);


        void layerRemove(int layer);

        void settingsSliderChanged(int value,int slider);

        void settingsSLModeChanged(int value);

        void settingsSLCompute();

        void settingsSLInverpolationChanged(int value);

        void settingsEmitSliderValue(int slider);
};

#endif // RENDERWIDGET_H