gliftEx1.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>
using namespace std;

#include <GL/glut.h>

#include <vec2.h>
#include <texNd.h>
#include <texDataNd.h>
#include <shader.h>
#include <planarQuad.h>
#include <shadedPrim.h>
#include <multiPrim.h>
#include <renderPass.h>
#include <glew.h>

using namespace gutz;
using namespace glift;

// Forward Decls
class Blend;

// Globals
Blend*       g_blend = NULL;
SingleTex*   g_greyTex = NULL;
RenderPass*  g_pass1 = NULL; // The object that will draw EVERYTHING
vec2i            g_winDimen(0);  // The x,y size of your window

GLubyte* genGrayImageRGB( int numElts )
{
  GLubyte* image = new GLubyte[numElts*numElts*3];
  
  unsigned long index = 0;
  
  GLubyte val = 0;
  for(int y=0; y < numElts; y++) {
    for(int x=0; x < numElts; x++) {
      for(int c=0; c < 3; c++) {
        image[index] = val;
        index++;
      }
    }
    if( y%1==0 ) {val += 35;}
  }

  return image;
}

// This is a testing texture setup.
// - The only part of this code you will need is marked below
SingleTex* setupGrayScaleGradTex( int numElts )
{
  GLubyte* image = genGrayImageRGB( numElts );
  
  // You'll use these 2 lines, but 'image' is your framebuffer from RTRT
  // or any other image.
  // - WARNING: The 'GL_INT' must match the format of the 'image'
  //            (GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE, etc).
  //            The image MUST by 'texDimen.w' x 'texDimen.h' x 3!!
  // - If you are using this for RGBA textures, change 'GL_RGB' to 'GL_RGBA'
  //   and make sure 'image' has 4 components instead of 3.
  MultiTexOState texState;
  texState << TS_S_CLAMP << TS_T_CLAMP << TS_LINEAR;
  TS_REPLACE->bind(GL_TEXTURE_2D);

  vec2i texDimen(numElts);
  TexDataArr1<ubyte> texData( GL_RGB, GL_UNSIGNED_BYTE, texDimen, arrayw1ub( numElts*numElts*3, image ) );

  SingleTex* greyTex = new Tex2D( texState, &texData );
  
  delete [] image;
  
  return greyTex;
}

class Color4f : public GenState
{
public:
  Color4f() {}
  Color4f( const vec4f& color ) {m_color = color;}
  void color( const vec4f& inColor) {m_color = inColor;}

protected:
  virtual void bindDef() {
    glColor4fv(m_color.v());
  }
  virtual void releaseDef() {}

private:
  vec4f m_color;
};

class Blend : public GenState
{
public:
  Blend() {}
  Blend( const vec4f& color ) {m_color = color;}
  void alpha( float alpha ) {m_color[3] = alpha;}
  
protected:
  virtual void bindDef() {
    glEnable(GL_BLEND);
    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
    glColor4fv( m_color.v() );
  }
  virtual void releaseDef() {
    glDisable(GL_BLEND);
  }

private:
  vec4f m_color;
};

//Blend* g_blend=NULL;

void init(void) 
{
  glew();

  vec2f winSize( g_winDimen.w, g_winDimen.h );     
    
  glClearColor (0.0, 0.0, 1.0, 0.0); //If we see blue background, it is the ColorBuffer
  
  // Create a large, black quad and set render state to ortho2D
  Color4f* red = new Color4f( vec4f(1.0, 0.0, 0.0, 0.0) );
  Shader*  redShader = new Shader(red);  
  PlanarQuad* windowSizedQuad = new PlanarQuad( vec2f(0.0f), winSize ); 
  ShadedPrim* bigRedQuad = new ShadedPrim(windowSizedQuad, redShader);
  //bigRedQuad->compile(); //Make into display list
  
  // Create the Shader to draw 'greyTex' to a quad in ortho2D mode
  // - Note: 'greyTex' will become any texture
  //         You can call 'greyTex->reset(GL_INT, image)'
  //         to pass in the new framebuffer from RTRT
          g_blend       = new Blend( vec4f(1.0, 1.0, 1.0, 0.5) );
                  g_greyTex     = setupGrayScaleGradTex(32); // The texture
  Shader* greyTexShader = new Shader( g_greyTex, g_blend );   // Turn it into a shader
  
  // Create a z-axis aligned, planar Quad with texture coordinates
  vec2f lowerLeft(  50, 50 );
  vec2f upperRight(200, 200);
  float z = 0.5;  
  bool  genTexCoords = true;
  PlanarQuad* smallQuad = new PlanarQuad( lowerLeft, upperRight, z, genTexCoords );
  //smallQuad->compile();

  ShadedPrim* smallTexturedQuad = new ShadedPrim( smallQuad, greyTexShader );
  
  // Create render pass...da' whole enchilada
  VecDrawP prims;
  prims.push_back( bigRedQuad );
  prims.push_back( smallTexturedQuad );
  
  g_pass1 = new RenderPass( prims );
  
  glerr("init()");
}

void display(void)
{
  static float alpha=0.0;
  
  glerr("display","1");
  glClear(GL_COLOR_BUFFER_BIT);

  // Draw entire scene
  g_pass1->render();
  glutSwapBuffers();

  //Update alpha
  alpha += 0.025f;
  alpha -= int(alpha);
  g_blend->alpha( alpha );
}

void reshape (int w, int h)
{
   g_winDimen = vec2i(w,h);
   glViewport (0, 0, (GLsizei) w, (GLsizei) h);
   
   glerr("reshape","1");
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity();
   gluOrtho2D( 0, w, 0, h );
   
   glerr("reshape","2");    
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   //gluLookAt( 0, 0, 1, 0, 0, 0, 0, 1, 0 );
   glerr("reshape","3");

   static int count=0;
   int numElts = count%2==0 ? 256 : 32;   
   GLubyte* image = genGrayImageRGB(numElts);
   TexData texData( GL_TEXTURE_2D, vec3i(), vec3i(numElts), 0,
                                    GL_RGB, GL_RGB, GL_UNSIGNED_BYTE, (void*)image);
   g_greyTex->setTexData(&texData);
   delete [] image;
   count++;
}

int main(int argc, char** argv)
{
  g_winDimen = vec2i(256, 256);

  glutInit(&argc, argv);
  glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGBA);
  glutInitWindowSize (g_winDimen.w, g_winDimen.h); 
  glutInitWindowPosition (100, 100);
  
  GLint mainWindow = glutCreateWindow("Texture This!");
  
  init ();
  glutDisplayFunc(display); 
  glutReshapeFunc(reshape);
  
  glErr(cerr, "main","main");
  glutMainLoop();
  return 0;
}

---

Send questions, comments, and bug reports to: