/*
 * Measure the speed of drawing many quads from the same texture.
 * Based on trispd.c:
 *
 * 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 MinPeriod = 2.0;   /* 2 seconds */
static int Width;
static int Height;
static int Loops = 1000;
static int Size = 10;
static int NBoxes = 10;

static void Idle( void )
{
    glutPostRedisplay();
}


static void Display( void )
{
    double t0, t1;
    int boxCount;
    double boxRate;
    double pixRate;
    float width = Width;
    float height = Height;
    int i, j;

    glClearColor( 0.0, 0.0, 1.0, 1.0 );
    glClear( GL_COLOR_BUFFER_BIT );

    t0 = glutGet(GLUT_ELAPSED_TIME) * 0.001;

    for (i=0; i<Loops; i++) {
	for (j = 0; j < NBoxes; j++) {
	    float x = j * (Size + 1);
	    float y = 0;
	    float u = x / width;
	    float uSize = Size / width;
	    float v = y / width;
	    float vSize = Size / height;
	    
	    glBegin(GL_TRIANGLE_FAN);
	    glTexCoord2f(u, v);
	    glVertex2f(x, y);
	    glTexCoord2f(u+uSize, v);
	    glVertex2f(x+Size, y);
	    glTexCoord2f(u+uSize, v+vSize);
	    glVertex2f(x+Size, y+Size);
	    glTexCoord2f(u, v+vSize);
	    glVertex2f(x, y+Size);
	    glEnd();
	}
    }
    
    glFinish();
    t1 = glutGet(GLUT_ELAPSED_TIME) * 0.001;
   
    if (t1-t0 < MinPeriod) {
	/* Next time draw more triangles to get longer elapsed time */
	Loops *= 2;
	return;
    }

    boxCount = NBoxes * Loops;
    boxRate = boxCount / (t1-t0);
    pixRate = boxRate * Size * Size;
    printf("Rate: %d boxes in %gs = %g boxes/s %g pix/sec\n",
	   boxCount, t1-t0, boxRate, pixRate);
    
    glutSwapBuffers();
}


static void Reshape( int width, int 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()
{
    GLubyte *pixels;
    int x, y;
    pixels = (GLubyte *) malloc(4*Width*Height);
    for (y = 0; y < Height; ++y)
	for (x = 0; x < Width; ++x) {
	    pixels[(y*Width+x)*4+0] = 255;
	    pixels[(y*Width+x)*4+1] = 0;
	    pixels[(y*Width+x)*4+2] = 0;
	    pixels[(y*Width+x)*4+3] = 255;
	}
    glEnable(GL_TEXTURE_2D);
    glTexImage2D(GL_TEXTURE_2D, 0, 4, Width, Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
}

static int nextPower(int n) {
    int result = 1;
    while (result < n)
	result *= 2;

    return result;
}

static void Init( int argc, char *argv[] )
{
    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],"-nboxes")==0) {
	    NBoxes = atoi(argv[i+1]);
	    i++;
	}
	else
	    printf("Unknown option: %s\n", argv[i]);
    }

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

    Width = nextPower((Size + 1) * NBoxes - 1);
    Height = nextPower(Size);
}


static void Help( const char *program )
{
    printf("%s options:\n",   program);
    printf("  -size pixels    specify size of boxes\n");
    printf("  -nboxes nboxes  number of boxes\n");
}


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

    glutInitWindowSize( Width, 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;
    }

    LoadTex();

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

    glutMainLoop();
    return 0;
}