gltest.cxx

Go to the documentation of this file.

//
// gltest.cxx
//
// A quick binary to see if OpenGL will correctly link in on your
// system, and show itself on your screen.
//
// Absolutely minimum fuss.
// 
#include <iostream>

#include <GL/gl.h>
#include <GL/glx.h>
#include <GL/glu.h>


#include <stdio.h>
#include <stdlib.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xos.h>
#include <X11/Xatom.h>
#include <X11/keysym.h>

#include <sys/time.h>

#ifdef USE_ASIMAGE
extern "C" {
#include "afterbase.h"
#include "afterimage.h"
}
#endif

using namespace std;

Display *dis;
Window win;

float X_Rot   = 0.9f;
float Y_Rot   = 0.0f;
float X_Speed = 0.0f;
float Y_Speed = 0.5f;
float Z_Off   =-5.0f;
// Settings for our light.  Try playing with these (or add more lights).
float Light_Ambient[]=  { 0.1f, 0.1f, 0.1f, 1.0f };
float Light_Diffuse[]=  { 1.2f, 1.2f, 1.2f, 1.0f };
float Light_Position[]= { 2.0f, 2.0f, 0.0f, 1.0f };

void draw_scene()
{
  glEnable(GL_LIGHTING);

  glEnable(GL_DEPTH_TEST);

  // Need to manipulate the ModelView matrix to move our model around.
   glMatrixMode(GL_MODELVIEW);

   // Reset to 0,0,0; no rotation, no scaling.
   glLoadIdentity();

   // Move the object back from the screen.
   glTranslatef(0.0f,0.0f,Z_Off);

   // Rotate the calculated amount.
   glRotatef(X_Rot,1.0f,0.0f,0.0f);
   glRotatef(Y_Rot,0.0f,1.0f,0.0f);


   // Clear the color and depth buffers.
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);


   // OK, let's start drawing our planer quads.
   glBegin(GL_QUADS);

   // Bottom Face.  Red, 75% opaque, magnified texture

   glNormal3f( 0.0f, -1.0f, 0.0f); // Needed for lighting
   glColor4f(0.9,0.2,0.2,.75); // Basic polygon color

   glTexCoord2f(0.800f, 0.800f); glVertex3f(-1.0f, -1.0f, -1.0f);
   glTexCoord2f(0.200f, 0.800f); glVertex3f( 1.0f, -1.0f, -1.0f);
   glTexCoord2f(0.200f, 0.200f); glVertex3f( 1.0f, -1.0f,  1.0f);
   glTexCoord2f(0.800f, 0.200f); glVertex3f(-1.0f, -1.0f,  1.0f);
  // Top face; offset.  White, 50% opaque.

   glNormal3f( 0.0f, 1.0f, 0.0f);  glColor4f(0.5,0.5,0.5,.5);

   glTexCoord2f(0.005f, 1.995f); glVertex3f(-1.0f,  1.3f, -1.0f);
   glTexCoord2f(0.005f, 0.005f); glVertex3f(-1.0f,  1.3f,  1.0f);
   glTexCoord2f(1.995f, 0.005f); glVertex3f( 1.0f,  1.3f,  1.0f);
   glTexCoord2f(1.995f, 1.995f); glVertex3f( 1.0f,  1.3f, -1.0f);


   // Far face.  Green, 50% opaque, non-uniform texture cooridinates.

   glNormal3f( 0.0f, 0.0f,-1.0f);  glColor4f(0.2,0.9,0.2,.5);

   glTexCoord2f(0.995f, 0.005f); glVertex3f(-1.0f, -1.0f, -1.3f);
   glTexCoord2f(2.995f, 2.995f); glVertex3f(-1.0f,  1.0f, -1.3f);
   glTexCoord2f(0.005f, 0.995f); glVertex3f( 1.0f,  1.0f, -1.3f);
   glTexCoord2f(0.005f, 0.005f); glVertex3f( 1.0f, -1.0f, -1.3f);


   // Right face.  Blue; 25% opaque

   glNormal3f( 1.0f, 0.0f, 0.0f);  glColor4f(0.2,0.2,0.9,.25);

   glTexCoord2f(0.995f, 0.005f); glVertex3f( 1.0f, -1.0f, -1.0f);
   glTexCoord2f(0.995f, 0.995f); glVertex3f( 1.0f,  1.0f, -1.0f);
   glTexCoord2f(0.005f, 0.995f); glVertex3f( 1.0f,  1.0f,  1.0f);
   glTexCoord2f(0.005f, 0.005f); glVertex3f( 1.0f, -1.0f,  1.0f);

  // Front face; offset.  Multi-colored, 50% opaque.

   glNormal3f( 0.0f, 0.0f, 1.0f);

   glColor4f( 0.9f, 0.2f, 0.2f, 0.5f);
   glTexCoord2f( 0.005f, 0.005f); glVertex3f(-1.0f, -1.0f,  1.3f);
   glColor4f( 0.2f, 0.9f, 0.2f, 0.5f);
   glTexCoord2f( 0.995f, 0.005f); glVertex3f( 1.0f, -1.0f,  1.3f);
   glColor4f( 0.2f, 0.2f, 0.9f, 0.5f);
   glTexCoord2f( 0.995f, 0.995f); glVertex3f( 1.0f,  1.0f,  1.3f);
   glColor4f( 0.1f, 0.1f, 0.1f, 0.5f);
   glTexCoord2f( 0.005f, 0.995f); glVertex3f(-1.0f,  1.0f,  1.3f);


   // Left Face; offset.  Yellow, varying levels of opaque.

   glNormal3f(-1.0f, 0.0f, 0.0f);

   glColor4f(0.9,0.9,0.2,0.0);
   glTexCoord2f(0.005f, 0.005f); glVertex3f(-1.3f, -1.0f, -1.0f);
   glColor4f(0.9,0.9,0.2,0.66);
   glTexCoord2f(0.995f, 0.005f); glVertex3f(-1.3f, -1.0f,  1.0f);
   glColor4f(0.9,0.9,0.2,1.0);
   glTexCoord2f(0.995f, 0.995f); glVertex3f(-1.3f,  1.0f,  1.0f);
   glColor4f(0.9,0.9,0.2,0.33);
   glTexCoord2f(0.005f, 0.995f); glVertex3f(-1.3f,  1.0f, -1.0f);


   // All polygons have been drawn.
   glEnd();
}






int main() {
  dis = XOpenDisplay(NULL);
  int width = 500;
  int height = 500;
  win = XCreateSimpleWindow(dis, RootWindow(dis, 0), 1, 1, width, height,       \
                            0, BlackPixel (dis, 0), BlackPixel(dis, 0));
  XMapWindow(dis, win);

  XFlush(dis);  

  static int dblBuf[] = {
    GLX_DOUBLEBUFFER,
    GLX_RGBA, GLX_DEPTH_SIZE, 16,
    GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
    None
  };
  static int *snglBuf = &dblBuf[1];
  
  XVisualInfo* visInfo = glXChooseVisual(dis, DefaultScreen(dis), dblBuf);
  if(visInfo ==0)
    visInfo = glXChooseVisual(dis, DefaultScreen(dis), snglBuf);
  if(visInfo ==0) 
    cout << "Can't find good visual!" << endl;

  GLXContext context = glXCreateContext(dis, visInfo, None, GL_TRUE);  

  glXMakeCurrent(dis, win, context); 

  glViewport(0,0,500,500);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(45.0,1.0,0.1,100.0);
  glMatrixMode(GL_MODELVIEW);

  // Color to clear color buffer to.
  glClearColor(0.1f, 0.1f, 0.1f, 0.0f);

  // Depth to clear depth buffer to; type of test.
  glClearDepth(1.0);
  glDepthFunc(GL_LESS);
  glShadeModel(GL_SMOOTH);
  
  // Set up a light, turn it on.
   glLightfv(GL_LIGHT1, GL_POSITION, Light_Position);
   glLightfv(GL_LIGHT1, GL_AMBIENT,  Light_Ambient);
   glLightfv(GL_LIGHT1, GL_DIFFUSE,  Light_Diffuse);
   glEnable (GL_LIGHT1);

   // A handy trick -- have surface material mirror the color.
   glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
   glEnable(GL_COLOR_MATERIAL);

   struct timeval t1;
   struct timeval t2;
   gettimeofday(&t1,NULL);
   int reps = 0;

   while(1) {
     draw_scene();
     glXSwapBuffers(dis, win);
     if (!glXIsDirect(dis, context)) {
      glFinish();
     }
     
     Y_Rot+=1;
     //usleep(100);

     // On my computer, this makes about 1 rev every 10 seconds.
     gettimeofday(&t2,NULL);
     double dt = (t2.tv_sec - t1.tv_sec)*1.0
       + (t2.tv_usec - t1.tv_usec)*1e-6;
     if(reps==100) {
       printf("FPS: %f\n",(double)reps/dt);
       t1.tv_sec = t2.tv_sec;
       t1.tv_usec = t2.tv_usec;
       reps=0;


#ifdef USE_ASIMAGE       
       {
         cout << "Writing... " << endl;
         
         XImage* ximage = XGetImage(dis,win,
                                    0,0,width,height,
                                    XAllPlanes(), ZPixmap);
         if(ximage==NULL) {
           cout << "Couldn't make the XImage! " << endl;
           exit(1);
         }
         
         int screen  =  DefaultScreen(dis);
         int depth   =  DefaultDepth(dis,screen);
         Visual *vis   = DefaultVisual(dis,screen);
         Colormap cmap = DefaultColormap(dis,screen);
         
         ASVisual* asv =  create_asvisual_for_id(dis,
                                                 screen, depth,
                                                 XVisualIDFromVisual(vis), 
                                                 cmap, 0);
         if(asv==0) {
           cout << "Couldn't make the ASVisual! " << endl;
           exit(1);
         }
         
         ASImage* asimage = ximage2asimage(asv, ximage, 10); // 10 is compression from 0 to 100
         if(asimage==0) {
           cout << "Couldn't make the ASImage! " << endl;
           exit(1);
         }                      
         
         const char* dir = ".";
         const char* file= "file.gif";
         ASImageFileTypes atype = ASIT_Gif;
         
         ASImageExportParams parms;
         switch (atype) {
         case ASIT_Xpm:
           parms.xpm.type = atype;
           parms.xpm.flags = EXPORT_ALPHA;
           parms.xpm.dither = 4;
           parms.xpm.opaque_threshold = 127;
           parms.xpm.max_colors = 512;
           break;
         case ASIT_Png:
           parms.png.type = atype;
           parms.png.flags = EXPORT_ALPHA;
           parms.png.compression = 50;
           break;
         case ASIT_Jpeg:
           parms.jpeg.type = atype;
           parms.jpeg.flags = 0;
           parms.jpeg.quality = ASIMAGE_QUALITY_GOOD; // also poor, fast, top
           break;
         case ASIT_Gif:
           parms.gif.type = atype;
           parms.gif.flags = EXPORT_ALPHA;
           parms.gif.dither = 0; 
           parms.gif.opaque_threshold = 0;
           break;
         case ASIT_Tiff:
           parms.tiff.type = atype;
           parms.tiff.flags = EXPORT_ALPHA;
           parms.tiff.rows_per_strip = 0;
           parms.tiff.compression_type = TIFF_COMPRESSION_JPEG;
           parms.tiff.jpeg_quality = 100;
           parms.tiff.opaque_threshold = 0;
           break;
         default:
           exit(0);
         }

         if(
            ASImage2file( asimage, dir, file,
                          atype, &parms )
            ) 
         cout << "Write successful!" << endl;
         else 
         cout << "Write failed!" << endl;
       }
       

#endif




     }
     reps++;
   }
   
   
   
   return(0);
}

---