/*
 * Simple GLUT program to measure triangle strip rendering speed.
 * Brian Paul  February 15, 1997  This file is in the public domain.
 */

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <GL/glut.h>


static float Width = 400.0;
static float Height = 400.0;
static int Size = 50;

#define TEXTURE_SIZE 16

static void Display( void )
{
   glClearColor( 1.0, 1.0, 1.0, 1.0 );
   glClear( GL_COLOR_BUFFER_BIT );

   glBegin(GL_QUADS);
   glTexCoord2f(- TEXTURE_SIZE, - TEXTURE_SIZE);
   glVertex2f(0, 0);
   glTexCoord2f(2 * TEXTURE_SIZE, - TEXTURE_SIZE);
   glVertex2f(Width, 0);
   glTexCoord2f(2 * TEXTURE_SIZE, 2 * TEXTURE_SIZE);
   glVertex2f(Width, Height);
   glTexCoord2f(- TEXTURE_SIZE, 2 * TEXTURE_SIZE);
   glVertex2f(0, Height);
   glEnd();
   glFinish();

   glutSwapBuffers();
}


static void Reshape( int width, int height )
{
   Width = width;
   Height = height;
   glViewport( 0, 0, width, height );
   glMatrixMode( GL_PROJECTION );
   glLoadIdentity();
   glOrtho(0.0, width, 0.0, height, -1.0, 1.0);
   glMatrixMode( GL_MODELVIEW );
   glLoadIdentity();
}


static void Key( unsigned char key, int x, int y )
{
   (void) x;
   (void) y;
   switch (key) {
      case 27:
         exit(0);
         break;
   }
   glutPostRedisplay();
}


static void LoadTex(int comp, int filter)
{
   GLubyte *pixels;
   GLfloat border_color[4] = { 0.0, 0.0, 0.3, 0.3 };
   int x, y;
   pixels = (GLubyte *) malloc(4*TEXTURE_SIZE*TEXTURE_SIZE);
   for (y = 0; y < TEXTURE_SIZE; ++y)
      for (x = 0; x < TEXTURE_SIZE; ++x) {
	  if ((x / 4 + y / 4) % 2 == 0) {
	      pixels[(y*TEXTURE_SIZE+x)*4+0] = 0;
	      pixels[(y*TEXTURE_SIZE+x)*4+1] = 255;
	      pixels[(y*TEXTURE_SIZE+x)*4+2] = 0;
	      pixels[(y*TEXTURE_SIZE+x)*4+3] = 255;
	  } else {
	      pixels[(y*TEXTURE_SIZE+x)*4+0] = 255;
	      pixels[(y*TEXTURE_SIZE+x)*4+1] = 255;
	      pixels[(y*TEXTURE_SIZE+x)*4+2] = 255;
	      pixels[(y*TEXTURE_SIZE+x)*4+3] = 255;
	  }
      }
   glEnable(GL_TEXTURE_RECTANGLE_ARB);
   glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, comp, TEXTURE_SIZE, TEXTURE_SIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
   glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, filter);
   glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, filter);
   glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
   glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
   glTexParameterfv(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_BORDER_COLOR, border_color);
   printf("Texture: %d comps, %s\n", comp, filter == GL_NEAREST ? "GL_NEAREST" : "GL_LINEAR");
}


static void Init( int argc, char *argv[] )
{
   GLint rBits, gBits, bBits;
   int filter = GL_NEAREST, comp = 3;

   int i;
   for (i=1; i<argc; i++) {
      if (strcmp(argv[i],"-size")==0) {
         Size = atoi(argv[i+1]);
         i++;
      }
      else if (strcmp(argv[i],"-linear")==0)
	 filter = GL_NEAREST;
      else if (strcmp(argv[i],"+linear")==0)
	 filter = GL_LINEAR;
      else if (strcmp(argv[i],"-comp")==0) {
	 comp = atoi(argv[i+1]);
	 i++;
      }
      else
         printf("Unknown option: %s\n", argv[i]);
   }

   printf("Size: %d pixels\n", Size);

   LoadTex(comp, filter);
   
   glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
   glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
   glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
   glEnable(GL_BLEND);
   glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

   glGetIntegerv(GL_RED_BITS, &rBits);
   glGetIntegerv(GL_GREEN_BITS, &gBits);
   glGetIntegerv(GL_BLUE_BITS, &bBits);
   printf("RedBits: %d  GreenBits: %d  BlueBits: %d\n", rBits, gBits, bBits);
}


static void Help( const char *program )
{
   printf("%s options:\n", program);
   printf("  -size pixels   specify pixels/triangle\n");
   printf("  -comp n        texture format\n");
   printf("  +/-linear      bilinear texture filter\n");
}


int main( int argc, char *argv[] )
{
   printf("For options:  %s -help\n", argv[0]);
   glutInit( &argc, argv );
   glutInitWindowSize( (int) Width, (int) Height );
   glutInitWindowPosition( 0, 0 );

   glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE );

   glutCreateWindow( argv[0] );

   if (argc==2 && strcmp(argv[1],"-help")==0) {
      Help(argv[0]);
      return 0;
   }

   Init( argc, argv );
   Reshape( Width, Height );

   glutReshapeFunc( Reshape );
   glutKeyboardFunc( Key );
   glutDisplayFunc( Display );

   glutMainLoop();
   return 0;

}