C:/Users/Michael/Documents/Visual Studio 2008/Projects/FlowVisFrame - Kopie/FlowVisFrame/glwidget.h

#ifndef GLWIDGET_H
#define GLWIDGET_H

#include "Arrows.h"
#include "Shader.h"
#include "Texture.h"
#include <QGLWidget>
#include <QReadWriteLock>
#include <il.h>
#include "Transferfunction.h"
#include "FBO.h"

#include "FlowData.h"
#include "Streamlines.h"
#include "States.h"

 #include <QMutex>
#include <QWaitCondition>

#include "GLTransfer.h"
class QtLogo;






class GLWidget : public QGLWidget
{
    Q_OBJECT

public:
        FBO* fbo;
        FBO* fbo2;
    GLWidget(QWidget *parent = 0, QWidget *transfer = 0, QWidget *transfer2 = 0);
        ~GLWidget();
    QSize minimumSizeHint() const;

    QSize sizeHint() const;

        States states; 

        static bool waiting;
        static bool waiting2;
        static bool waiting3;
        QReadWriteLock* mutex2;
        static QWaitCondition condition;

        QColor getArrowColor();
        std::string integType; 
        
        QWidget* m_scatter;
        


public slots:

        void arrowLayer(bool active);


        void backgroundLayer(bool active);

        void streamlineLayer(bool active);

        void arrowSize(int size);

        void arrowDistance(int distance);

        void integration(QString type);

        void dstep(int step);

        void dtest(int test);

        void dt(int dt);

        void backLayerOpac(int backOpacity); 

        void arrowLayerOpac(int arrowOpac);

        void slicLayerOpac(int opacity);

        void glyph(bool check);

        void tapering(bool check);

        void openFile();

        void openColorChooser();

        void timeSlider(int time);

        void arrowVelocity(bool active);

        void slTextrue(bool active);

        void dtest();

        void dsteps();
        void dstepsize();

        void dsep();

        void dt();

        void dtime();

        void nsteps(int);

        void stepsize(int);


        //void nslider(int n);
signals:

        void arrowLayerChanged(bool active);

        void backgroundLayerChanged(bool active);

        void streamlineLayerChanged(bool active);

        void arrowSizeChanged(int size);

        void arrowDistanceChanged(int distance); 

        void integrationChanged(QString type);
        

        void dstepChanged(int step);

        void dtestChanged(int test); 

        void dtChanged(int dt);

        void glyphChanged(bool check);

        void taperingChanged(bool check);

        void backLayerOpacChanged(int backOpacity); 

        void arrowLayerOpacChanged(int arrowOpac); 

        void slicLayerOpacChanged(int slicOpac);

        void timeSliderChanged(int time);

        void arrowVelocityChanged(bool active);

        void slTextrueChanged(bool active);


        void nsliderChanged(int n);

protected:

    void initializeGL();

    void paintGL();

    void resizeGL(int width, int height);

    void mousePressEvent(QMouseEvent *event);

    void mouseMoveEvent(QMouseEvent *event);

        void wheelEvent(QWheelEvent *event);

        void mouseReleaseEvent(QMouseEvent *event);

private:
        QWidget* m_parent;
        int initLibs();

        int nexttimestep;
        float nextdt;
        float nextstepsize;
        float nextnumsteps;
        float nextdtest;
        float nextdsep;
        States::StreamlineIntMode nextIntegrationMode;


        QReadWriteLock qrw_timestep;
        QReadWriteLock qrw_dt;
        QReadWriteLock qrw_stepsize;
        QReadWriteLock qrw_numsteps;
        QReadWriteLock qrw_dtest;
        QReadWriteLock qrw_dsep;
        QReadWriteLock qrw_inte;


        vec3 cameraTranslation;

private:

        void updateThread();

        void updateCamera();
        std::vector<ThreadQTImplementation*> qt;
    QtLogo *logo;
    int xRot;
    int yRot;
    int zRot;
    QPoint lastPos;
    QColor qtGreen;
    QColor qtPurple;

        Arrows* arrows;
        Arrows* glyphs;
        Shader* shader;
        Texture* gridtexture;
        FlowData* dataset;
        int chX;
        int chY;
        int vel;


        QWidget* m_transfer;

        std::vector<float> diffx;
        std::vector<float> diffy;

        std::vector<std::vector<std::vector<StreamlineObj*>>> stream;

        void loadData(string filename);


        void upateTFTextureIntern(Transferfunction points, int actIndex, bool update);

        
        GLuint scatterfunc;
        float texscatter[512*512*4];

        std::vector<Texture*> texture;
        std::vector<Texture*> texture2;
        std::vector<Texture*> texture_scatter;

        Texture* gridtexture_copy;
        std::vector<Texture*> texture_copy;

        int actTS;
        
        QColor arrowColor;

        //-----------
        GLfloat texturefunction[1024*4];
        GLuint transferfunc;

public slots:

    void updatePixmap(StreamlineObj* streamv, int index1, int index2);

        void updateTFTexture(const Transferfunction tex, int index, bool update);
        void createdTexture(const vec3 pos1, vec3 pos2, bool update);

signals:

        void sendTexture(std::vector<Texture*> asdf);
        void stopSignal();

        void startSignal(vec3 startp, Texture* grid, Texture* tex, int numsteps, float stepsize, float dsep, float dtest, float dt, States::StreamlineIntMode intmode);

//      void nsliderChanged(int n);

};

#endif