studium/Visualisierung/LU Stuff/sources/bsp2/src/renderer/Renderer.h

#ifndef RENDERER_H
#define RENDERER_H

#include <GL/freeglut.h>

#include <string>
#include <vector>


#include "../utils/FlowData.h"
#include "../utils/StreamlineGrid.h"
#include "../utils/vec3.h"

#include <semaphore.h>

class Renderer
{
 public:
        struct TFPoint
        {
                unsigned int pos; 
                unsigned char r; 
                unsigned char g; 
                unsigned char b; 
                unsigned char a; 
        };

        struct TransferFunction
        {
                GLuint texID; 
                unsigned int width; 
                std::vector<TFPoint> points; 
                int* histo;
                int* maxHist;

                unsigned char* data; 

                TransferFunction()
                {
                        this->width = 0;
                        this->texID = 0;
                        this->data = 0;
                        //this->points = new std::vector<TFPoint>();
                }
        };

        Renderer();
        ~Renderer();

        void setStreamlines(bool);
        void setArrows(bool);

        void setArrowSize(float);

        void setDTest(float);
        void setDSep(int);
        void setStepSize(float);

        void setDataset(int);
        void setChannel(int);

        void setTransferFunction(TransferFunction&);

        void initGL();
        void resizeGL(int, int);
        void paintGL();

        void animate();

        int * getHisto() { return this->histo; };
        int * getMaxHist() { return this->maxHist; };

 private:
        static Renderer* instance;

        double loopFactor;
        clock_t timestamp;

        FlowData* dataset;

        int* histo;

        int* maxHist;

        GLuint width;
        GLuint height;

        int channelIndex;

        int timeStepIndex;

        int xCountArrows;
        int yCountArrows;

        float xArrowDist;
        float yArrowDist;

        float arrowSize;

        GLuint transferTexture;

        GLint transferTextureLocation;

        GLuint arrowTexture;
        GLint arrowTextureLocation;

        GLint arrowPlottingProgram;
        GLint arrowPlottingChannelTexturesLocations[2];

        GLint colorCodingProgram;
        GLint colorCodingChannelTextureLocation;

        vector<GLuint*> timeStepTextures;
        vector<vector<float*> > timeStepData;

        float newStepSize;
        int newDSep;

        float stepSize;
        int dSep;
        StreamlineGrid* streamlineGrid;

        bool doArrows;
        bool doStreamlines;

        void loadArrowTexture();
        void preprocessFlowData();

        void renderChannel();
        void renderArrows();
        void renderStreamlines();

        void checkGLFeatures();

        static bool create2DTexture(GLuint*, int, int, void*);

        static GLuint createProgram(const std::string&, const std::string&);
        static GLint queryUniformLoc(GLint, const GLchar*);
        static bool readShaderSource(const std::string&, std::string&);

        sem_t mutex;

        static void* generateTimestepTextures(void*);
};

#endif

---