Eigene Dateien/FlowVis/src/VFlowRenderer.h

Go to the documentation of this file.

#pragma once

#ifndef _v_flow_renderer_h
#define _v_flow_renderer_h

#include "VFlowData.h"
#include "VCamera.h"
#include "VProgram.h"
#include "VImage.h"
#include "VWhiteNoise.h"

__interface ShaderWrapper
{
        void set( int m_TimeStep );

        void clean();

};

class VFlowRenderer
{
public:

        VFlowRenderer();

        void processGuiInput(float dist, VVector pos, VVector view, VVector up, VVector lookAt);

        void setTransferFunctionHandle(unsigned int handle)
        {
                m_TransferFunctionHandle = handle;
        }

        void setArrowTransferFunctionHandle(unsigned int handle)
        {
                m_ArrowTransferFunctionHandle = handle;
        }

        void setStreamLineTransferFunctionHandle(unsigned int handle)
        {
                m_StreamLineTransferFunctionHandle = handle;
        }

        void setLicTransferFunctionHandle(unsigned int handle)
        {
                m_LicTransferFunctionHandle = handle;
        }

        void setCurrentShader( int val );

        VVector getCameraSideVector()
        {
                VMatrix viewm = mCamera.getViewMatrix();

                return VVector(viewm[0], viewm[4], viewm[8]);
        }

        float getFlowDataMin()
        {
        
                return mFlowData->getMinimalDatavalue( activeDataValue - 1 );
        }

        float getFlowDataMax()
        {
        
                return mFlowData->getMaximalDatavalue( activeDataValue - 1 );
        }

        VVector getCameraUpVector()
        {
                VMatrix viewm = mCamera.getViewMatrix();

                return VVector(viewm[1], viewm[5], viewm[9]);
        }

        void resize(int width, int height);

        void draw(int m_TimeStep = 0);

        void drawGlyphes(int m_TimeStep = 0);

        void drawStreamLines();

        void drawIcons();

        void drawLic( int m_TimeStep = 0 );

        bool getProgramLoaded()
        {
                return mProgramLoaded;
        }

        void setFlowData(VFlowData * m_FlowData)
        {
                mFlowData = m_FlowData;
        }

        void setBasicGlyphSize(float m_GlyphSize)
        {
                mBaseGlyphSize = m_GlyphSize;
        }

        void setGlyph(bool val)
        {
                mUseGlyph =  val;
        }

        void setStrGlyphes(bool val)
        {
                mStrGlyphes =  val;
        }

        void setArrowScaleMode( bool val )
        {
                arrows_nonunifcale = (val) ? 0.0f : 1.0f;
        }
        
        void setArrowAlpha( float val)
        {
                arrowalpha = val;
        }

        void setStreamLineAlpha( float val)
        {
                streamlinesalpha = val;
        }

        void setLicAlpha( float val)
        {
                licalpha = val;
        }

        void setLicSteps( int val)
        {
                licsteps = val;
        }

        void setLicStepSize( int val)
        {
                licstepsize = val;
        }

        void setArrowColorPtr(VVector * v)
        {
                arrowColor = v;
        }

        void enableArrowTF( bool val )
        {
                arrowTfActivated = val;
        }

        void enableLicTF( bool val )
        {
                licTfActivated = val;
        }

        void animateLic( bool val )
        {
                mAnimateLic = val;
        }

        void enableStrTF( bool val )
        {
                streamlineTfActivated = val;
        }

        void setStreamlinesColorPtr(VVector * v)
        {
                streamlinesColor = v;
        }

        float getCameraFOV()
        {
                return mCamera.getFov();
        }

        float getCameraAspect()
        {
                return mCamera.getAspecRatio();
        }

        VMatrix getCameraProjMatrix()
        {
                return mCamera.getProjMatrix();
        }

        VMatrix getCameraViewMatrix()
        {
                return VMatrix( mCamera.getViewMatrix() );
        }

        void loadProgram();

        void generateFrolic(float m_Width, float m_Height);

        void setShaderWrapperVelocity();

        void clearShaderWrapperVelocity();

        void setShaderWrapperPressure();

        void clearShaderWrapperPressure();

        void setShaderWrapperVorticity();

        void clearShaderWrapperVorticity();

        void setShaderWrapperStreamLines();

        void clearShaderWrapperStreamLines();

        void setShaderWrapperStreamLinesGlyph();

        void clearShaderWrapperStreamLinesGlyph();

        void setShaderWrapperStreamLinesTf(int m_TimeStep);

        void clearShaderWrapperStreamLinesTf();

        void setShaderWrapperStreamLinesTfGlyph(int m_TimeStep);

        void clearShaderWrapperStreamLinesTfGlyph();

        void setShaderWrapperLIC( int m_TimeStep );

        void clearShaderWrapperLIC();

        void setShaderWrapperLICTexture( int m_TimeStep );

        void clearShaderWrapperLICTexture();

        void setShaderWrapperOLICTexture( int m_TimeStep );

        void clearShaderWrapperOLICTexture();

        void setShaderWrapperLICTf( int m_TimeStep );

        void clearShaderWrapperLICTf();

        void setShaderWrapperLICTextureTf( int m_TimeStep );

        void clearShaderWrapperLICTextureTf();

        class ShaderWrapperVelocity: public ShaderWrapper
        {
        public:
                VFlowRenderer *vrendererptr;                            
                ShaderWrapperVelocity(VFlowRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }

                void ShaderWrapperVelocity::set( int m_TimeStep )
                {
                        vrendererptr->setShaderWrapperVelocity();
                }

                void ShaderWrapperVelocity::clean()
                {
                        vrendererptr->clearShaderWrapperVelocity();
                }

                ~ShaderWrapperVelocity()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperPressure: public ShaderWrapper
        {
        public:
                VFlowRenderer *vrendererptr;                            
                ShaderWrapperPressure(VFlowRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }

                void ShaderWrapperPressure::set( int m_TimeStep )
                {
                        vrendererptr->setShaderWrapperPressure();
                }

                void ShaderWrapperPressure::clean()
                {
                        vrendererptr->clearShaderWrapperPressure();
                }

                ~ShaderWrapperPressure()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperVorticity: public ShaderWrapper
        {
        public:
                VFlowRenderer *vrendererptr;                            
                ShaderWrapperVorticity(VFlowRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }

                void ShaderWrapperVorticity::set( int m_TimeStep )
                {
                        vrendererptr->setShaderWrapperVorticity();
                }

                void ShaderWrapperVorticity::clean()
                {
                        vrendererptr->clearShaderWrapperVorticity();
                }

                ~ShaderWrapperVorticity()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        void setShaderWrapperGlyph();

        void clearShaderWrapperGlyph();

        class ShaderWrapperGlyph: public ShaderWrapper
        {
        public:
                VFlowRenderer *vrendererptr;                            
                ShaderWrapperGlyph(VFlowRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }

                void ShaderWrapperGlyph::set( int m_TimeStep )
                {
                        vrendererptr->setShaderWrapperGlyph();
                }

                void ShaderWrapperGlyph::clean()
                {
                        vrendererptr->clearShaderWrapperGlyph();
                }

                ~ShaderWrapperGlyph()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        void setShaderWrapperGlyphTf();

        void clearShaderWrapperGlyphTf();

        class ShaderWrapperGlyphTf: public ShaderWrapper
        {
        public:
                VFlowRenderer *vrendererptr;                            
                ShaderWrapperGlyphTf(VFlowRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }

                void ShaderWrapperGlyphTf::set( int m_TimeStep )
                {
                        vrendererptr->setShaderWrapperGlyphTf();
                }

                void ShaderWrapperGlyphTf::clean()
                {
                        vrendererptr->clearShaderWrapperGlyphTf();
                }

                ~ShaderWrapperGlyphTf()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        void setShaderWrapperIcon();

        void clearShaderWrapperIcon();

        class ShaderWrapperIcon: public ShaderWrapper
        {
        public:
                VFlowRenderer *vrendererptr;                            
                ShaderWrapperIcon(VFlowRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }

                void ShaderWrapperIcon::set( int m_TimeStep )
                {
                        vrendererptr->setShaderWrapperIcon();
                }

                void ShaderWrapperIcon::clean()
                {
                        vrendererptr->clearShaderWrapperIcon();
                }

                ~ShaderWrapperIcon()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperStreamLines: public ShaderWrapper
        {
        public:
                VFlowRenderer *vrendererptr;                            
                ShaderWrapperStreamLines(VFlowRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }

                void ShaderWrapperStreamLines::set( int m_TimeStep )
                {
                        vrendererptr->setShaderWrapperStreamLines();
                }

                void ShaderWrapperStreamLines::clean()
                {
                        vrendererptr->clearShaderWrapperStreamLines();
                }

                ~ShaderWrapperStreamLines()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperStreamLinesGlyph: public ShaderWrapper
        {
        public:
                VFlowRenderer *vrendererptr;                            
                ShaderWrapperStreamLinesGlyph(VFlowRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }

                void ShaderWrapperStreamLinesGlyph::set( int m_TimeStep )
                {
                        vrendererptr->setShaderWrapperStreamLinesGlyph();
                }

                void ShaderWrapperStreamLinesGlyph::clean()
                {
                        vrendererptr->clearShaderWrapperStreamLinesGlyph();
                }

                ~ShaderWrapperStreamLinesGlyph()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperStreamLinesTf: public ShaderWrapper
        {
        public:
                VFlowRenderer *vrendererptr;                            
                ShaderWrapperStreamLinesTf(VFlowRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }

                void ShaderWrapperStreamLinesTf::set( int m_TimeStep )
                {
                        vrendererptr->setShaderWrapperStreamLinesTf( m_TimeStep );
                }

                void ShaderWrapperStreamLinesTf::clean()
                {
                        vrendererptr->clearShaderWrapperStreamLinesTf();
                }

                ~ShaderWrapperStreamLinesTf()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperStreamLinesTfGlyph: public ShaderWrapper
        {
        public:
                VFlowRenderer *vrendererptr;                            
                ShaderWrapperStreamLinesTfGlyph(VFlowRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }

                void ShaderWrapperStreamLinesTfGlyph::set( int m_TimeStep )
                {
                        vrendererptr->setShaderWrapperStreamLinesTfGlyph( m_TimeStep );
                }

                void ShaderWrapperStreamLinesTfGlyph::clean()
                {
                        vrendererptr->clearShaderWrapperStreamLinesTfGlyph();
                }

                ~ShaderWrapperStreamLinesTfGlyph()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperLIC: public ShaderWrapper
        {
        public:
                VFlowRenderer *vrendererptr;                            
                ShaderWrapperLIC(VFlowRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }

                void ShaderWrapperLIC::set( int m_TimeStep )
                {
                        vrendererptr->setShaderWrapperLIC( m_TimeStep);
                }

                void ShaderWrapperLIC::clean()
                {
                        vrendererptr->clearShaderWrapperLIC();
                }

                ~ShaderWrapperLIC()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperLICTexture: public ShaderWrapper
        {
        public:
                VFlowRenderer *vrendererptr;                            
                ShaderWrapperLICTexture(VFlowRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }

                void ShaderWrapperLICTexture::set( int m_TimeStep )
                {
                        vrendererptr->setShaderWrapperLICTexture( m_TimeStep);
                }

                void ShaderWrapperLICTexture::clean()
                {
                        vrendererptr->clearShaderWrapperLICTexture();
                }

                ~ShaderWrapperLICTexture()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperOLICTexture: public ShaderWrapper
        {
        public:
                VFlowRenderer *vrendererptr;                            
                ShaderWrapperOLICTexture(VFlowRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }

                void ShaderWrapperOLICTexture::set( int m_TimeStep )
                {
                        vrendererptr->setShaderWrapperOLICTexture( m_TimeStep);
                }

                void ShaderWrapperOLICTexture::clean()
                {
                        vrendererptr->clearShaderWrapperOLICTexture();
                }

                ~ShaderWrapperOLICTexture()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperLICTf: public ShaderWrapper
        {
        public:
                VFlowRenderer *vrendererptr;                            
                ShaderWrapperLICTf(VFlowRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }

                void ShaderWrapperLICTf::set( int m_TimeStep )
                {
                        vrendererptr->setShaderWrapperLICTf( m_TimeStep);
                }

                void ShaderWrapperLICTf::clean()
                {
                        vrendererptr->clearShaderWrapperLICTf();
                }

                ~ShaderWrapperLICTf()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperLICTextureTf: public ShaderWrapper
        {
        public:
                VFlowRenderer *vrendererptr;                            
                ShaderWrapperLICTextureTf(VFlowRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }

                void ShaderWrapperLICTextureTf::set( int m_TimeStep )
                {
                        vrendererptr->setShaderWrapperLICTextureTf( m_TimeStep);
                }

                void ShaderWrapperLICTextureTf::clean()
                {
                        vrendererptr->clearShaderWrapperLICTextureTf();
                }

                ~ShaderWrapperLICTextureTf()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

private:

        VFlowData * mFlowData;                                                                  
        VCamera mCamera;                                                                                
        ShaderWrapper * mCurrentMode;                                                   
        ShaderWrapperVelocity mShaderWrapperVelocity;                   
        ShaderWrapperPressure mShaderWrapperPressure;                   
        ShaderWrapperVorticity mShaderWrapperVorticity;                 
        ShaderWrapperStreamLines mShaderWrapperStreamLines;             
        ShaderWrapperStreamLinesGlyph mShaderWrapperStreamLinesGlyph;           
        ShaderWrapperStreamLinesTf mShaderWrapperStreamLinesTf;         
        ShaderWrapperStreamLinesTfGlyph mShaderWrapperStreamLinesTfGlyph;               
        ShaderWrapperLIC mShaderWrapperLIC;                                             
        ShaderWrapperLICTexture mShaderWrapperLICTexture;                                               
        ShaderWrapperOLICTexture mShaderWrapperOLICTexture;                                             
        ShaderWrapperLICTf mShaderWrapperLICTf;                                         
        ShaderWrapperLICTextureTf mShaderWrapperLICTextureTf;                                           
        ShaderWrapperIcon mShaderWrapperIcon;                                   
        VProgram mVelocityProgram;                                                              
        VProgram mPressureProgram;                                                              
        VProgram mVorticityProgram;                                                             
        VProgram mRenderToVBProgram;                                                    
        VProgram mRenderToVBProgramGlyph;                                                       
        VProgram mRenderToVBProgramTf;                                                  
        VProgram mRenderToVBProgramTfGlyph;                                                     
        VProgram mLICProgram;                                                                   
        VProgram mLICProgramTexture;                                                                    
        VProgram mOLICProgramTexture;                                                                   
        VProgram mIconProgram;                                                                  
        VProgram mLICProgramTf;                                                                 
        VProgram mLICProgramTextureTf;                                                                  
        ShaderWrapperGlyph mShaderWrapperGlyph;                                 
        VProgram mGlyphProgram;                                                                 
        ShaderWrapperGlyphTf mShaderWrapperGlyphTf;                                     
        VProgram mGlyphProgramTf;                                                                       
        bool mProgramLoaded;                                                                    
        VImage mGlyph;                                                                                  
        VImage mTriangle;                                                                                       
        bool mUseGlyph;                                                                                 
        unsigned int m_TransferFunctionHandle;                                  
        unsigned int m_ArrowTransferFunctionHandle;                                     
        unsigned int m_StreamLineTransferFunctionHandle;                                        
        unsigned int m_LicTransferFunctionHandle;                               
        float mBaseGlyphSize;                                                                   
        float mCameraDistance;

        int activeDataValue;

        //relevant to GUI
        int arrows_nonunifcale;                                 
        float arrowalpha;                                               
        bool arrowTfActivated;                                  
        VVector * arrowColor;                                   
        VVector * streamlinesColor;                             
        bool streamlineTfActivated;                             
        float streamlinesalpha;                                 
        VWhiteNoise mWhiteNoise;                                
        VImage mPerlinNoise;

        float licalpha;                                                 
        int licsteps;                                                   
        int licstepsize;                                                
        bool licTfActivated;                                    
        bool mStrGlyphes;                                               
        unsigned int mGaussTextureHandle;               
        float mLicTextureOffset;                                
        bool mAnimateLic;                                               
};

#endif // _v_flow_renderer_h

---