rtt.cpp

Go to the documentation of this file.

// 6/14/02      Aaron Lefohn    Scientific Computing and Imaging Institute      
// School of Computing          University of Utah
//
// This is a simple app to test render-to-texture
// - This version developed on ATI Radeon 8500
// - This program has been converted to OOGL objects.

#include <iostream.h>
#include <GL/glui.h>

#include <glew.h>

#include <vec2.h>
#include <vec3.h>
#include <pbuffGlift.h>
#include <texNd.h>
#include <multiTex.h>
#include <shader.h>
#include <pixelShaderATI8K.h>
#include <texCoordPerturb.h>
#include <planarQuad.h>
#include <shadedPrim.h>
#include <renderPass.h>
#include <texDataNd.h>

using namespace gutz;
using namespace glift;

GLUI*            g_glui=NULL;
RenderPass*      g_pass1 = NULL;
RenderPass*      g_pass2 = NULL;
SingleTex*       g_greyTex = NULL;
PBuffer*         g_pbuff = NULL;
DrawableGLI* g_prim = NULL;
vec2i            g_dimen(0);

class RenderState2D : public GenState
{
protected:
        virtual void bindDef()
        {
                glerr("drawQuad","1");
                glDisable(GL_DEPTH_TEST);
                glMatrixMode(GL_PROJECTION);
                glPushMatrix();
                        glLoadIdentity();
                        gluOrtho2D(0.0, (GLdouble)g_dimen.w, 0.0, (GLdouble)g_dimen.h);
                        //glOrtho(0.0, (GLdouble)g_dimen.w, 0.0, (GLdouble)g_dimen.h, 1.0, -1.0 );
                        glMatrixMode(GL_MODELVIEW);
                        glPushMatrix();
                        glLoadIdentity();
        }

        virtual void releaseDef()
        {
                        glPopMatrix();
                        glMatrixMode(GL_PROJECTION);
                glPopMatrix();
                glMatrixMode(GL_MODELVIEW);
                glEnable(GL_DEPTH_TEST);
                glerr("RenderState2D","release()");
        }
};

class GlutSphere : public DrawableGLI
{
protected:
        virtual void drawDef() { glutSolidSphere (1.0, 30, 20); }
};

void multTwoShaderATI()
{
#ifdef GLIFT_ATI
        glSampleMapATI( GL_REG_0_ATI, GL_TEXTURE0_ARB, GL_SWIZZLE_STR_ATI ); 

        glColorFragmentOp2ATI( GL_ADD_ATI, GL_REG_0_ATI, GL_NONE, GL_HALF_BIT_ATI,      
                                                   GL_REG_0_ATI, GL_NONE, GL_NONE,
                                                   GL_REG_0_ATI, GL_NONE, GL_NONE );

#endif
}

void diffShaderATI()
{
#ifdef GLIFT_ATI
        glSampleMapATI( GL_REG_0_ATI, GL_TEXTURE0_ARB, GL_SWIZZLE_STR_ATI );
        glSampleMapATI( GL_REG_1_ATI, GL_TEXTURE1_ARB, GL_SWIZZLE_STR_ATI );

        glColorFragmentOp2ATI( GL_SUB_ATI, GL_REG_0_ATI, GL_NONE, GL_2X_BIT_ATI | GL_SATURATE_BIT_ATI,
                                                   GL_REG_0_ATI, GL_NONE, GL_NONE,
                                                   GL_REG_1_ATI, GL_NONE, GL_NONE );

/*      glColorFragmentOp1ATI( GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE,
                                                   GL_REG_1_ATI, GL_NONE, GL_NONE );
*/
#endif
}

// This is a testing texture used to generate various grayscale images
SingleTex* setupGrayScaleGradTex( PBuffer* pbuff )
{
        int numElts = 256;
        arrayo1ub image(numElts*numElts);

        unsigned long index = 0;
        
        GLubyte val = 0;
        for(int y=0; y < numElts; y++) {
                for(int x=0; x < numElts; x++) {
                        image[index] = val;
                        index++;
                }
                if( y%10==0 ) {val += 50;}
        }

        // Setup the texture object state
        MultiTexOState texState;                                
        texState << TS_S_CLAMP << TS_T_CLAMP << TS_NEAREST;

        // Setup the texture unit state (default to texUnit 0)
        TS_REPLACE->bind(GL_TEXTURE_2D);

        // Setup the data wrapper
        vec2i texDimen(numElts, numElts);
        TexDataArr1<uchar> texData( GL_LUMINANCE, GL_UNSIGNED_BYTE, texDimen, image );
        
        // Setup the texture
        SingleTex* greyTex = new Tex2D( texState, &texData, pbuff );


        return greyTex;
}


void pbuffInit()
{
        glMatrixMode (GL_PROJECTION);
        glLoadIdentity();
        //glOrtho( 0, g_dimen.w, 0, g_dimen.h, +1, -10);
    gluPerspective( 90.0, 1.0, 1.0, -10.0);
    gluLookAt( 0, 0, 3, 0, 0, 0, 0, 1, 0 );

        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();

        glClearColor (1.0, 0.0, 0.0, 0.0); // If we see red background, it is the PBuffer
        glShadeModel (GL_SMOOTH);
        glEnable(GL_DEPTH_TEST);

        GLfloat mat_specular[] = { 1.0, 0.5, 0.5, 1.0 };
        GLfloat light_position[] = { 0.0, 0.0, +5, 1.0 };
        glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_specular);
        glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
        glMaterialf(GL_FRONT, GL_SHININESS, 25.0);
        glLightfv(GL_LIGHT0, GL_POSITION, light_position);
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);

        //glColorMaterial(GL_FRONT, GL_DIFFUSE);
        //glColor4fv(mat_specular);
        //glEnable(GL_COLOR_MATERIAL);

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glEnableClientState(GL_VERTEX_ARRAY);
}

void init(void) 
{  
        glew();
  
        glClearColor (0.0, 0.0, 1.0, 0.0); //If we see blue background, it is the ColorBuffer

        // Create the pbuffer
        g_pbuff = new PBuffer( g_dimen, GLUT_SINGLE | GLUT_RGBA, pbuffInit, true, true );

        // Create the Shader for pass that draws 'greyTex' to pbuffer
        PixelShader*    multTwoShader   = NULL;
        #ifdef GLIFT_ATI
                multTwoShader = new PixelShaderATI8K( multTwoShaderATI, g_pbuff );
        #endif
                                        g_greyTex               = setupGrayScaleGradTex( NULL );
        RenderState2D*  render2D                = new RenderState2D();
        Shader*                 greyTexShader   = new Shader( g_greyTex, new ProgShader(1, multTwoShader), render2D );
        //Shader*                       greyTexShader   = new Shader( greyTex, attribs );
        //greyTexShader->compile();

        // Create Shader for pass that draws contents of Pbuffer to color buffer
        MultiTexOState texState;
        texState << TS_S_CLAMP << TS_R_CLAMP << TS_NEAREST;
        SingleTex* pbuffTex                 = new Tex2D( texState, g_pbuff);
        Shader*    drawPbuffShader  = new Shader( pbuffTex, render2D );

        // Create Shader for derivative shader
        TexTrans texShift0( 0, vec2f(-1.0, +1.0), true );
        TexTrans texShift1( 1, vec2f(+1.0, -1.0), true );
        VecTexTrans               vecTexShift;
        vecTexShift.push_back( texShift0 );
        vecTexShift.push_back( texShift1 );

        TexCoordPerturb*  texPerturb   = new TexCoordPerturb( 2, vecTexShift );
        
        PixelShader*   diffShader   = NULL;
        #ifdef GLIFT_ATI
                diffShader = new PixelShaderATI8K( diffShaderATI, g_pbuff );
        #endif
        ProgShader* progShader   = new ProgShader( 2, diffShader, texPerturb );
        MultiTex*       greyTextures = new MultiTex( VecTexP(2, g_greyTex) );
        Shader*         derivShader  = new Shader( greyTextures, progShader, render2D );

        Shader*  drawTexShader = new Shader( g_greyTex, render2D );

        // Create the primitives
        PlanarQuad* quad           = new PlanarQuad( vec2f(0.0f), vec2f(g_dimen.w, g_dimen.h), -1.0f, true );
        GlutSphere* glutSphere = new GlutSphere();
        g_prim = glutSphere;  
 
        // Create the shadedPrims
        ShadedPrim* shadedPrimGreyTex = new ShadedPrim( quad, greyTexShader );// The shaded prim for pass 1
        ShadedPrim* shadedPrimDeriv       = new ShadedPrim( quad, derivShader );
        ShadedPrim* shadedPrimPbuff   = new ShadedPrim( quad, drawPbuffShader );// The shaded prim for pass 2
        ShadedPrim* shadedPrimTex         = new ShadedPrim( quad, drawTexShader );
 
        // Create the render passes
        g_pass1 = new RenderPass( shadedPrimDeriv, g_pbuff, true );//glutSphere, g_pbuff, true );//new RenderPass( shadedPrimTex );//
        g_pass2 = new RenderPass( shadedPrimPbuff );//  shadedPrimPbuff ); //shadedPrimDeriv );//
  
        //g_pass1->compile();  
        //g_pass2->compile();  

        glerr("init()","");
}

void display(void)
{
        glerr("display","1");
        glClear(GL_COLOR_BUFFER_BIT);

        g_pass1->render();
        g_pass2->render();

        glFlush();
        //glutSwapBuffers();
}

void reshape (int w, int h)
{
   g_dimen = vec2i(w,h);

   glerr("reshape","1");
   glViewport (0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity();
   //glOrtho( 0, w, 0, h, -1, -10);
   gluPerspective( 90.0, 1.0, 1, -10.0);
   gluLookAt( 0, 0, 3, 0, 0, -5, 0, 1, 0 );
   
   glErr("reshape","2");    
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   glErr("reshape","3");
}

void setupGluiStuff( GLint& mainWindow )
{       
        // Create GLUI control window
        g_glui = GLUI_Master.create_glui( "GUI", 0, 400, 50 );

        //Quit Button
        g_glui->add_button( "Quit", 0,(GLUI_Update_CB) exit);
        
        // which is the main gfx window!
        g_glui->set_main_gfx_window(mainWindow);
}

int main(int argc, char** argv)
{
        g_dimen = vec2i(256, 256);
        glutInit(&argc, argv);
        glutInitDisplayMode (GLUT_SINGLE | GLUT_RGBA);
        glutInitWindowSize (g_dimen.w, g_dimen.h); 
        glutInitWindowPosition (100, 100);

        GLint mainWindow = glutCreateWindow("Texture This!");
        GLUI_Master.set_glutIdleFunc( NULL ); 
                   
        init ();
        glutDisplayFunc(display); 
        glutReshapeFunc(reshape);

        setupGluiStuff( mainWindow );

        glErr("main","main");
        glutMainLoop();
        return 0;
}

---

Send questions, comments, and bug reports to: