Eigene Dateien/FlowVis/src/VFlowRenderer.cpp

Go to the documentation of this file.

#include "VFlowRenderer.h"
#include "glew.h"
#include "VImage.h"


VFlowRenderer::VFlowRenderer() : mProgramLoaded( false ),
        mShaderWrapperVelocity( this ),
        mShaderWrapperPressure( this ),
        mShaderWrapperVorticity( this ),
        mShaderWrapperGlyph( this ),
        mShaderWrapperGlyphTf(this),
        mShaderWrapperStreamLines ( this ),
        mShaderWrapperStreamLinesGlyph( this ),
        mShaderWrapperStreamLinesTf( this ),
        mShaderWrapperStreamLinesTfGlyph( this ),
        mShaderWrapperIcon(this),
        mShaderWrapperLIC( this ),
        mShaderWrapperLICTf( this ),
        mShaderWrapperLICTexture( this ),
        mShaderWrapperOLICTexture( this ),
        mShaderWrapperLICTextureTf(this),
        mFlowData( NULL ),
        mBaseGlyphSize(0.5f),
        mCameraDistance(20.0f),
        arrows_nonunifcale(0.0f),
        arrowalpha(1.0f),
        streamlinesalpha(1.0f),
        arrowTfActivated(false),
        streamlineTfActivated(false),
        licalpha(1.0f),
        licsteps(250),
        licstepsize(500),
        mUseGlyph(true),
        mStrGlyphes(false),
        licTfActivated(false),
        mLicTextureOffset(0.0f),
        mAnimateLic(false)
{
        VVector eye( 5.0f, 0.0f, -20.0f );
        VVector view( 0.0f, 0.0f, 1.0f );
        VVector up( 0.0f, 1.0f, 0.0f );
        
        mCamera.lookInDirection( eye, view, up );
        mCurrentMode = &mShaderWrapperVelocity;

}

void VFlowRenderer::processGuiInput( float dist, VVector position, VVector view, VVector up, VVector lookAt )
{
        //VVector view = lookAt - position;
        //view.normalize();
        VVector lview = view * dist;

        VVector campos = lookAt - lview;

        //view.normalize();

        mCamera.lookInDirection( campos, view, up );
        mCameraDistance = dist;
}

void VFlowRenderer::setCurrentShader( int val )
{

        switch ( val )
        {
        
                case 1:
                {
                        mCurrentMode = &mShaderWrapperVelocity;
                        activeDataValue = val;
                        break;
                }
                case 2:
                {
                        mCurrentMode = &mShaderWrapperPressure;
                        activeDataValue = val;
                        break;
                }
                case 3:
                {
                        mCurrentMode = &mShaderWrapperVorticity;
                        activeDataValue = val;
                        break;
                }
                default:
                {
                        mCurrentMode = &mShaderWrapperVelocity;
                        activeDataValue = val;
                        break;
                }
        }
}

void VFlowRenderer::resize( int width, int height )
{
        mCamera.setProjection( width, height );
}

void VFlowRenderer::draw( int m_TimeStep /* = 0 */ )
{
        if( mFlowData )
        {
                mCurrentMode->set( m_TimeStep );
                mFlowData->draw( m_TimeStep );
                mCurrentMode->clean();
        }       
}

void VFlowRenderer::drawGlyphes( int m_TimeStep /* = 0 */ )
{
        if( mFlowData )
        {
                if(arrowTfActivated)
                {
                        mShaderWrapperGlyphTf.set( m_TimeStep );
                        mFlowData->drawPoints( m_TimeStep );
                        mShaderWrapperGlyphTf.clean();

                }
                else
                {
                        mShaderWrapperGlyph.set( m_TimeStep );
                        mFlowData->drawPoints( m_TimeStep );
                        mShaderWrapperGlyph.clean();
                }
        }
}

void VFlowRenderer::drawStreamLines()
{
        if( mFlowData )
        {
                if(!mStrGlyphes)
                {
                        if( streamlineTfActivated )
                        {
                                mShaderWrapperStreamLinesTf.set( 0 );
                                mFlowData->drawStreamLines( streamlinesColor );
                                mShaderWrapperStreamLinesTf.clean();
                        }
                        else
                        {
                                mShaderWrapperStreamLines.set( 0 );
                                mFlowData->drawStreamLines( streamlinesColor );
                                mShaderWrapperStreamLines.clean();
                        }
                }
                else
                {
                        if( streamlineTfActivated )
                        {
                                mShaderWrapperStreamLinesTfGlyph.set( 0 );
                                mFlowData->drawStreamLines( streamlinesColor );
                                mShaderWrapperStreamLinesTfGlyph.clean();
                        }
                        else
                        {
                                mShaderWrapperStreamLinesGlyph.set( 0 );
                                mFlowData->drawStreamLines( streamlinesColor );
                                mShaderWrapperStreamLinesGlyph.clean();
                        }
                }
                
        }
}

void VFlowRenderer::drawIcons()
{
        if( mFlowData )
        {
                mShaderWrapperIcon.set(0);
                mFlowData->drawIcons();
                mShaderWrapperIcon.clean();
        }
}

void VFlowRenderer::drawLic( int m_TimeStep /* = 0 */ )
{
        if(licTfActivated)
        {
                if(mAnimateLic)
                        mShaderWrapperLICTextureTf.set( m_TimeStep );
                else
                        mShaderWrapperLICTf.set( m_TimeStep );
        }
        else
        {
                if(mAnimateLic)
                        mShaderWrapperLICTexture.set( m_TimeStep );
                else 
                        mShaderWrapperLIC.set( m_TimeStep );
        }
        

        //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
        //glDisable(GL_DEPTH_TEST);
        glBegin(GL_QUADS);
        glTexCoord2f(1.0f, 0.0f);
        glVertex3f(mFlowData->getMinPos().getX(), mFlowData->getMinPos().getY(), -0.00f);
        glTexCoord2f(0.0f, 0.0f);
        glVertex3f(mFlowData->getMaxPos().getX(), mFlowData->getMinPos().getY(), -0.00f);
        glTexCoord2f(0.0f, 1.0f);
        glVertex3f(mFlowData->getMaxPos().getX(), mFlowData->getMaxPos().getY(), -0.00f);
        glTexCoord2f(1.0f, 1.0f);
        glVertex3f(mFlowData->getMinPos().getX(), mFlowData->getMaxPos().getY(), -0.00f);
        glEnd();
        //glEnable(GL_DEPTH_TEST);

        //glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

        if(licTfActivated)
        {
                if(mAnimateLic)
                        mShaderWrapperLICTextureTf.clean();
                else
                        mShaderWrapperLICTf.clean();
        }
        else
        {
                if(mAnimateLic)
                        mShaderWrapperLICTexture.clean();
                else
                        mShaderWrapperLIC.clean();
        }
        
        VImage::renderOuterScreen(mWhiteNoise.getFrolicHandle());
}

void VFlowRenderer::loadProgram()
{
        mVelocityProgram =  VProgram(VVertexShader("shader/flow_vertex.glsl"), VFragmentShader("shader/velocity_fragment.glsl"));
        mPressureProgram =  VProgram(VVertexShader("shader/flow_vertex.glsl"), VFragmentShader("shader/pressure_fragment.glsl"));
        mVorticityProgram =  VProgram(VVertexShader("shader/flow_vertex.glsl"), VFragmentShader("shader/vorticity_fragment.glsl"));
        mGlyphProgram = VProgram(VVertexShader("shader/glyph_vertex.glsl"), VFragmentShader("shader/glyph_fragment.glsl"));
        mGlyphProgramTf = VProgram(VVertexShader("shader/glyph_vertex.glsl"), VFragmentShader("shader/glyph_fragment_tf.glsl"));
        mRenderToVBProgram = VProgram( VVertexShader("shader/rendervertexbuffer_vertex.glsl"), VFragmentShader("shader/rendervertexbuffer_fragment.glsl") );
        mRenderToVBProgramGlyph = VProgram( VVertexShader("shader/rendervertexbuffer_vertex_gl.glsl"), VFragmentShader("shader/rendervertexbuffer_fragment_gl.glsl") );
        mRenderToVBProgramTf = VProgram( VVertexShader("shader/rendervertexbuffer_vertex_tf.glsl"), VFragmentShader("shader/rendervertexbuffer_fragment_tf.glsl") );
        mRenderToVBProgramTfGlyph = VProgram( VVertexShader("shader/rendervertexbuffer_vertex_tf_gl.glsl"), VFragmentShader("shader/rendervertexbuffer_fragment_tf_gl.glsl") );
        mLICProgram = VProgram(VVertexShader("shader/lic_vertex.glsl"), VFragmentShader("shader/lic_fragment.glsl"));
        mLICProgramTexture = VProgram(VVertexShader("shader/lic_vertex.glsl"), VFragmentShader("shader/lic_fragment_tx.glsl"));
        mOLICProgramTexture = VProgram(VVertexShader("shader/lic_vertex.glsl"), VFragmentShader("shader/olic_fragment_tx.glsl"));

        mLICProgramTf = VProgram(VVertexShader("shader/lic_vertex_tf.glsl"), VFragmentShader("shader/lic_fragment_tf.glsl"));
        mLICProgramTextureTf = VProgram(VVertexShader("shader/lic_vertex_tf.glsl"), VFragmentShader("shader/lic_fragment_tx_tf.glsl"));

        mIconProgram = VProgram(VVertexShader("shader/icon_vertex.glsl"), VFragmentShader("shader/icon_fragment.glsl"));

        mGlyph.loadImage("textures/arrow.png");
        mTriangle.loadImage("textures/triangle.png");
        mPerlinNoise.loadImage("textures/noise.png");

        mWhiteNoise.generate(256, 256, 20);

        float gauss[41] = 
        {
                0.0010,
            0.0014,
            0.0021,
            0.0030,
            0.0042,
            0.0058,
            0.0077,
            0.0102,
            0.0132,
            0.0166,
            0.0206,
            0.0250,
            0.0298,
            0.0347,
            0.0396,
            0.0443,
            0.0486,
            0.0522,
            0.0549,
            0.0566,
                0.0572,
            0.0566,
            0.0549,
            0.0522,
            0.0486,
            0.0443,
            0.0396,
            0.0347,
            0.0298,
            0.0250,
            0.0206,
            0.0166,
            0.0132,
            0.0102,
            0.0077,
            0.0058,
            0.0042,
            0.0030,
            0.0021,
            0.0014,
            0.0010
        };

        float sawtooth[41] = 
        {
                0.0,
                0.0,
                0.0,
                0.0,
                0.0,
                0.0,
                0.0,
                0.0,
                0.0,
                0.0,
                0.0,
                0.0024,
                0.0049,
                0.0073,
                0.0098,
                0.0122,
                0.0146,
                0.0171,
                0.0195,
                0.0220,
                0.0244,
                0.0268,
                0.0293,
                0.0317,
                0.0341,
                0.0366,
                0.0390,
                0.0415,
                0.0439,
                0.0463,
                0.0488,
                //0.0012,
                //0.0037,
                //0.0061,
                //0.0085,
                //0.0110,
                //0.0134,
                //0.0159,
                //0.0183,
                //0.0207,
                //0.0232,
                //0.0256,
                //0.0280,
                //0.0305,
                //0.0329,
                //0.0354,
                //0.0378,
                //0.0402,
                //0.0427,
                //0.0451,
                0.0,
                0.0,
                0.0,
                0.0,
                0.0,
                0.0,
                0.0,
                0.0,
                0.0,
                0.0
        };

        std::vector<float> mTextureBase;

        for ( int i = 0; i < 41; ++i )
        {
                /*mTextureBase.push_back (sawtooth[i] * 2.0f);
                mTextureBase.push_back (sawtooth[i] * 2.0f);
                mTextureBase.push_back (sawtooth[i] * 2.0f);*/
                mTextureBase.push_back (gauss[i]);
                mTextureBase.push_back (gauss[i]);
                mTextureBase.push_back (gauss[i]);
                mTextureBase.push_back (1.0f);
        }

        glGenTextures (1, &mGaussTextureHandle);
        glBindTexture(GL_TEXTURE_2D, mGaussTextureHandle);

        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

        gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA16F_ARB, 41, 1, GL_RGBA, GL_FLOAT, &(mTextureBase[0]));
        //glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, mWidth, mHeight, GL_RGBA, GL_FLOAT, &(tmp[0]));

        glBindTexture(GL_TEXTURE_2D, 0);
        glDisable(GL_TEXTURE_2D);

        mProgramLoaded = true;


        const GLenum glError = glGetError();

        if (glError != GL_NO_ERROR)
                std::cout << "Error Loading Programs " << gluErrorString(glError) << std::endl;
}

void VFlowRenderer::generateFrolic(float m_Width, float m_Height)
{
        float factor;
        int x, y;

        if(m_Width < m_Height)
        {
                x = (int)(256.0f * m_Width / m_Height);
                y = 256;
        }
        else
        {
                x = 256;
                y = (int)(256.0f * m_Height / m_Width);
        }
        mWhiteNoise.generateFrolicTexture(x, y);
}

---