progs/demos/gltestperf.c - fp2-dev/platform/external/mesa3d - Gitiles

 /*
  * This program is under the GNU GPL.
  * Use at your own risk.
  *
  * written by David Bucciarelli (tech.hmw@plus.it)
  *            Humanware s.r.l.
  */

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

 typedef struct
 {
    char *name;
    char *unit;
    void (*init) (void);
    int (*run) (int, int);
    int type;
    int numsize;
    int size[10];
 }
 benchmark;

 static int frontbuffer = 1;

 /***************************************************************************/

 static void
 init_test01(void)
 {
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(-0.5, 639.5, -0.5, 479.5);
    glMatrixMode(GL_MODELVIEW);

    glShadeModel(GL_FLAT);
    glDisable(GL_DEPTH_TEST);

    glClearColor(0.0, 0.1, 1.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(1.0, 0.0, 0.0);
 }

 static int
 test01(int size, int num)
 {
    int x, y;

    glBegin(GL_POINTS);
    for (y = 0; y < num; y++)
       for (x = 0; x < 480; x++)
 	 glVertex2i(x, x);
    glEnd();

    return 480 * num;
 }

 /***************************************************************************/

 static void
 init_test02(void)
 {
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(-0.5, 639.5, -0.5, 479.5);
    glMatrixMode(GL_MODELVIEW);

    glShadeModel(GL_SMOOTH);
    glDisable(GL_DEPTH_TEST);

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

 static int
 test02(int size, int num)
 {
    int x, y;

    glBegin(GL_LINES);
    for (y = 0; y < num; y++)
       for (x = 0; x < size; x++) {
 	 glColor3f(0.0, 1.0, y / (float) num);
 	 glVertex2i(0, size - 1);
 	 glColor3f(1.0, 0.0, x / (float) size);
 	 glVertex2i(x, x);
       }
    glEnd();

    return num * size;
 }

 /***************************************************************************/

 static void
 init_test03(void)
 {
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-0.5, 639.5, -0.5, 479.5, 1.0, -1000.0 * 480.0);
    glMatrixMode(GL_MODELVIEW);

    glShadeModel(GL_SMOOTH);
    glEnable(GL_DEPTH_TEST);

    glClearColor(0.0, 0.1, 1.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 }

 static int
 test03(int size, int num)
 {
    int x, y, z;

    glBegin(GL_TRIANGLES);
    for (y = 0; y < num; y++)
       for (x = 0; x < size; x += 5) {
 	 z = num * size - (y * size + x);
 	 glColor3f(0.0, 1.0, 0.0);
 	 glVertex3i(0, x, z);

 	 glColor3f(1.0, 0.0, x / (float) size);
 	 glVertex3i(size - 1 - x, 0, z);

 	 glColor3f(1.0, x / (float) size, 0.0);
 	 glVertex3i(x, size - 1 - x, z);
       }
    glEnd();

    return size * num / 5;
 }

 /***************************************************************************/

 static void
 init_test04(void)
 {
    int x, y;
    GLubyte tex[128 * 128 * 3];
    GLenum gluerr;

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-0.5, 639.5, -0.5, 479.5, 1.0, -1000.0 * 480.0);

    glMatrixMode(GL_MODELVIEW);

    glShadeModel(GL_SMOOTH);
    glEnable(GL_DEPTH_TEST);

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    for (y = 0; y < 128; y++)
       for (x = 0; x < 128; x++) {
 	 tex[(x + y * 128) * 3 + 0] = ((x % (128 / 4)) < (128 / 8)) ? 255 : 0;
 	 tex[(x + y * 128) * 3 + 1] = ((y % (128 / 4)) < (128 / 8)) ? 255 : 0;
 	 tex[(x + y * 128) * 3 + 2] = x;
       }

    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    if ((gluerr = gluBuild2DMipmaps(GL_TEXTURE_2D, 3, 128, 128, GL_RGB,
 				   GL_UNSIGNED_BYTE, (GLvoid *) (&tex[0])))) {
       fprintf(stderr, "GLULib%s\n", (char *) gluErrorString(gluerr));
       exit(-1);
    }

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
 		   GL_LINEAR_MIPMAP_NEAREST);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    glEnable(GL_TEXTURE_2D);

    glClearColor(0.0, 0.1, 1.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 }

 static int
 test04(int size, int num)
 {
    int x, y, z;

    glBegin(GL_TRIANGLES);
    for (y = 0; y < num; y++)
       for (x = 0; x < size; x += 5) {
 	 z = num * size - (y * size + x);
 	 glTexCoord2f(1.0, 1.0);
 	 glColor3f(1.0, 0.0, 0.0);
 	 glVertex3i(0, x, z);

 	 glTexCoord2f(0.0, 1.0);
 	 glColor3f(0.0, 1.0, 0.0);
 	 glVertex3i(size - 1 - x, 0, z);

 	 glTexCoord2f(1.0, 0.0);
 	 glColor3f(0.0, 0.0, 1.0);
 	 glVertex3i(x, size - 1 - x, z);
       }
    glEnd();

    return num * size / 5;
 }

 /***************************************************************************/

 static void
 init_test05(void)
 {
    int x, y;
    GLubyte tex[128 * 128 * 3];
    GLenum gluerr;

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-0.5, 639.5, -0.5, 479.5, -1.0, 1.0);

    glMatrixMode(GL_MODELVIEW);

    glShadeModel(GL_SMOOTH);
    glEnable(GL_DEPTH_TEST);

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    for (y = 0; y < 128; y++)
       for (x = 0; x < 128; x++) {
 	 tex[(x + y * 128) * 3 + 0] = ((x % (128 / 4)) < (128 / 8)) ? 255 : 0;
 	 tex[(x + y * 128) * 3 + 1] = ((y % (128 / 4)) < (128 / 8)) ? 255 : 0;
 	 tex[(x + y * 128) * 3 + 2] = x;
       }

    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    if ((gluerr = gluBuild2DMipmaps(GL_TEXTURE_2D, 3, 128, 128, GL_RGB,
 				   GL_UNSIGNED_BYTE, (GLvoid *) (&tex[0])))) {
       fprintf(stderr, "GLULib%s\n", (char *) gluErrorString(gluerr));
       exit(-1);
    }

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
 		   GL_LINEAR_MIPMAP_NEAREST);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    glEnable(GL_TEXTURE_2D);

    glDepthFunc(GL_ALWAYS);

    glClearColor(0.0, 0.1, 1.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 }

 static int
 test05(int size, int num)
 {
    int y;
    float v0[3], v1[3], v2[3], v3[3];
    float cv0[3], cv1[3], cv2[3], cv3[3];
    float tv0[3], tv1[3], tv2[3], tv3[3];

    v0[0] = 320 - size / 2;
    v0[1] = 240 - size / 2;
    v0[2] = 0.0;
    v1[0] = 320 + size / 2;
    v1[1] = 240 - size / 2;
    v1[2] = 0.0;
    v2[0] = 320 - size / 2;
    v2[1] = 240 + size / 2;
    v2[2] = 0.0;
    v3[0] = 320 + size / 2;
    v3[1] = 240 + size / 2;
    v3[2] = 0.0;
    cv0[0] = 1.0;
    cv0[1] = 0.0;
    cv0[2] = 0.0;
    cv1[0] = 1.0;
    cv1[1] = 1.0;
    cv1[2] = 0.0;
    cv2[0] = 1.0;
    cv2[1] = 0.0;
    cv2[2] = 1.0;
    cv3[0] = 1.0;
    cv3[1] = 1.0;
    cv3[2] = 1.0;
    tv0[0] = 0.0;
    tv0[1] = 0.0;
    tv0[2] = 0.0;
    tv1[0] = 1.0;
    tv1[1] = 0.0;
    tv1[2] = 0.0;
    tv2[0] = 0.0;
    tv2[1] = 1.0;
    tv2[2] = 0.0;
    tv3[0] = 1.0;
    tv3[1] = 1.0;
    tv3[2] = 0.0;

    glBegin(GL_TRIANGLE_STRIP);
    for (y = 0; y < num; y++) {
       glColor3fv(cv0);
       glTexCoord2fv(tv0);
       glVertex3fv(v0);

       glColor3fv(cv1);
       glTexCoord2fv(tv1);
       glVertex3fv(v1);

       glColor3fv(cv2);
       glTexCoord2fv(tv2);
       glVertex3fv(v2);

       glColor3fv(cv3);
       glTexCoord2fv(tv3);
       glVertex3fv(v3);
    }
    glEnd();

    return 4 * num - 2;
 }

 /***************************************************************************/

 static void
 init_test06(void)
 {
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(-0.5, 639.5, -0.5, 479.5);
    glMatrixMode(GL_MODELVIEW);

    glShadeModel(GL_SMOOTH);
    glEnable(GL_DEPTH_TEST);

    glClearColor(0.0, 0.1, 1.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 }

 static int
 test06(int size, int num)
 {
    int y;

    for (y = 0; y < num; y++) {
       glClearColor(y / (float) num, 0.1, 1.0, 0.0);
       glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    }

    return num;
 }

 /***************************************************************************/

 #define BMARKS_TIME 5.0

 #define NUM_BMARKS 6

 /* 554 ~= sqrt(640*480) */

 static benchmark bmarks[NUM_BMARKS] = {
    {"Simple Points", "Pnts", init_test01, test01, 0, 0,
     {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
    {"Smooth Lines", "Lins", init_test02, test02, 1, 5,
     {480, 250, 100, 50, 25, 0, 0, 0, 0, 0}},
    {"ZSmooth Triangles", "Tris", init_test03, test03, 1, 5,
     {480, 250, 100, 50, 25, 0, 0, 0, 0, 0}},
    {"ZSmooth Tex Blend Triangles", "Tris", init_test04, test04, 1, 5,
     {480, 250, 100, 50, 25, 0, 0, 0, 0, 0}},
    {"ZSmooth Tex Blend TMesh Triangles", "Tris", init_test05, test05, 2, 8,
     {400, 250, 100, 50, 25, 10, 5, 2, 0, 0}},
    {"Color/Depth Buffer Clears", "Clrs", init_test06, test06, 3, 0,
     {554, 0, 0, 0, 0, 0, 0, 0, 0, 0}}
 };

 /***************************************************************************/

 static void
 dotest0param(benchmark * bmark)
 {
    float stime, etime, dtime, tottime, maxtime, mintime;
    int num, numelem, calibnum, j;

    glPushAttrib(GL_ALL_ATTRIB_BITS);
    bmark->init();

    stime = glutGet(GLUT_ELAPSED_TIME);

    dtime = 0.0;
    calibnum = 0;
    while (dtime < 2.0) {
       bmark->run(0, 1);
       glFinish();
       etime = glutGet(GLUT_ELAPSED_TIME);
       dtime = (etime - stime) / 1000.0;
       calibnum++;
    }
    glPopAttrib();

    fprintf(stderr, "Elapsed time for the calibration test (%d): %f\n",
 	   calibnum, dtime);

    num = (int) ((BMARKS_TIME / dtime) * calibnum);

    if (num < 1)
       num = 1;

    fprintf(stderr, "Selected number of benchmark iterations: %d\n", num);

    mintime = HUGE_VAL;
    maxtime = -HUGE_VAL;

    for (tottime = 0.0, j = 0; j < 5; j++) {
       glPushAttrib(GL_ALL_ATTRIB_BITS);
       bmark->init();

       stime = glutGet(GLUT_ELAPSED_TIME);
       numelem = bmark->run(0, num);
       glFinish();
       etime = glutGet(GLUT_ELAPSED_TIME);

       glPopAttrib();

       dtime = (etime - stime) / 1000.0;
       tottime += dtime;

       fprintf(stderr, "Elapsed time for run %d: %f\n", j, dtime);

       if (dtime < mintime)
 	 mintime = dtime;
       if (dtime > maxtime)
 	 maxtime = dtime;
    }

    tottime -= mintime + maxtime;

    fprintf(stdout, "%s\n%f %s/sec", bmark->name, numelem / (tottime / 3.0),
 	   bmark->unit);

    if (bmark->type == 3)
       fprintf(stdout, ", MPixel Fill/sec: %f\n\n",
 	      (numelem * bmark->size[0] * (float) bmark->size[0]) /
 	      (1000000.0 * tottime / 3.0));
    else
       fprintf(stdout, "\n\n");
 }

 /***************************************************************************/

 static void
 dotest1param(benchmark * bmark)
 {
    float stime, etime, dtime, tottime, maxtime, mintime;
    int num, numelem, calibnum, j, k;

    fprintf(stdout, "%s\n", bmark->name);

    for (j = 0; j < bmark->numsize; j++) {
       fprintf(stderr, "Current size: %d\n", bmark->size[j]);

       glPushAttrib(GL_ALL_ATTRIB_BITS);
       bmark->init();

       stime = glutGet(GLUT_ELAPSED_TIME);

       dtime = 0.0;
       calibnum = 0;
       while (dtime < 2.0) {
 	 bmark->run(bmark->size[j], 1);
 	 glFinish();
 	 etime = glutGet(GLUT_ELAPSED_TIME);
 	 dtime = (etime - stime) / 1000.0;
 	 calibnum++;
       }
       glPopAttrib();

       fprintf(stderr, "Elapsed time for the calibration test (%d): %f\n",
 	      calibnum, dtime);

       num = (int) ((BMARKS_TIME / dtime) * calibnum);

       if (num < 1)
 	 num = 1;

       fprintf(stderr, "Selected number of benchmark iterations: %d\n", num);

       mintime = HUGE_VAL;
       maxtime = -HUGE_VAL;

       for (numelem = 1, tottime = 0.0, k = 0; k < 5; k++) {
 	 glPushAttrib(GL_ALL_ATTRIB_BITS);
 	 bmark->init();

 	 stime = glutGet(GLUT_ELAPSED_TIME);
 	 numelem = bmark->run(bmark->size[j], num);
 	 glFinish();
 	 etime = glutGet(GLUT_ELAPSED_TIME);

 	 glPopAttrib();

 	 dtime = (etime - stime) / 1000.0;
 	 tottime += dtime;

 	 fprintf(stderr, "Elapsed time for run %d: %f\n", k, dtime);

 	 if (dtime < mintime)
 	    mintime = dtime;
 	 if (dtime > maxtime)
 	    maxtime = dtime;
       }

       tottime -= mintime + maxtime;

       fprintf(stdout, "SIZE=%03d => %f %s/sec", bmark->size[j],
 	      numelem / (tottime / 3.0), bmark->unit);
       if (bmark->type == 2)
 	 fprintf(stdout, ", MPixel Fill/sec: %f\n",
 		 (numelem * bmark->size[j] * bmark->size[j] / 2) /
 		 (1000000.0 * tottime / 3.0));
       else
 	 fprintf(stdout, "\n");
    }

    fprintf(stdout, "\n\n");
 }

 /***************************************************************************/

 static void
 display(void)
 {
    int i;

    if (frontbuffer)
       glDrawBuffer(GL_FRONT);
    else
       glDrawBuffer(GL_BACK);

    for (i = 0; i < NUM_BMARKS; i++) {
       fprintf(stderr, "Benchmark: %d\n", i);

       switch (bmarks[i].type) {
       case 0:
       case 3:
 	 dotest0param(&bmarks[i]);
 	 break;
       case 1:
       case 2:
 	 dotest1param(&bmarks[i]);
 	 break;
       }
    }

    exit(0);
 }

 int
 main(int ac, char **av)
 {
    fprintf(stderr, "GLTest v1.0\nWritten by David Bucciarelli\n");

    if (ac == 2)
       frontbuffer = 0;

    glutInit(&ac, av);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowPosition(0, 0);
    glutInitWindowSize(640, 480);
    glutCreateWindow("OpenGL/Mesa Performances");
    glutDisplayFunc(display);
    glutMainLoop();

    return 0;
 }
	/*
	* This program is under the GNU GPL.
	* Use at your own risk.
	*
	* written by David Bucciarelli (tech.hmw@plus.it)
	* Humanware s.r.l.
	*/

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

	typedef struct
	{
	char *name;
	char *unit;
	void (*init) (void);
	int (*run) (int, int);
	int type;
	int numsize;
	int size[10];
	}
	benchmark;

	static int frontbuffer = 1;

	/***************************************************************************/

	static void
	init_test01(void)
	{
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluOrtho2D(-0.5, 639.5, -0.5, 479.5);
	glMatrixMode(GL_MODELVIEW);

	glShadeModel(GL_FLAT);
	glDisable(GL_DEPTH_TEST);

	glClearColor(0.0, 0.1, 1.0, 0.0);
	glClear(GL_COLOR_BUFFER_BIT);
	glColor3f(1.0, 0.0, 0.0);
	}

	static int
	test01(int size, int num)
	{
	int x, y;

	glBegin(GL_POINTS);
	for (y = 0; y < num; y++)
	for (x = 0; x < 480; x++)
	glVertex2i(x, x);
	glEnd();

	return 480 * num;
	}

	/***************************************************************************/

	static void
	init_test02(void)
	{
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluOrtho2D(-0.5, 639.5, -0.5, 479.5);
	glMatrixMode(GL_MODELVIEW);

	glShadeModel(GL_SMOOTH);
	glDisable(GL_DEPTH_TEST);

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

	static int
	test02(int size, int num)
	{
	int x, y;

	glBegin(GL_LINES);
	for (y = 0; y < num; y++)
	for (x = 0; x < size; x++) {
	glColor3f(0.0, 1.0, y / (float) num);
	glVertex2i(0, size - 1);
	glColor3f(1.0, 0.0, x / (float) size);
	glVertex2i(x, x);
	}
	glEnd();

	return num * size;
	}

	/***************************************************************************/

	static void
	init_test03(void)
	{
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(-0.5, 639.5, -0.5, 479.5, 1.0, -1000.0 * 480.0);
	glMatrixMode(GL_MODELVIEW);

	glShadeModel(GL_SMOOTH);
	glEnable(GL_DEPTH_TEST);

	glClearColor(0.0, 0.1, 1.0, 0.0);
	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
	}

	static int
	test03(int size, int num)
	{
	int x, y, z;

	glBegin(GL_TRIANGLES);
	for (y = 0; y < num; y++)
	for (x = 0; x < size; x += 5) {
	z = num * size - (y * size + x);
	glColor3f(0.0, 1.0, 0.0);
	glVertex3i(0, x, z);

	glColor3f(1.0, 0.0, x / (float) size);
	glVertex3i(size - 1 - x, 0, z);

	glColor3f(1.0, x / (float) size, 0.0);
	glVertex3i(x, size - 1 - x, z);
	}
	glEnd();

	return size * num / 5;
	}

	/***************************************************************************/

	static void
	init_test04(void)
	{
	int x, y;
	GLubyte tex[128 * 128 * 3];
	GLenum gluerr;

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(-0.5, 639.5, -0.5, 479.5, 1.0, -1000.0 * 480.0);

	glMatrixMode(GL_MODELVIEW);

	glShadeModel(GL_SMOOTH);
	glEnable(GL_DEPTH_TEST);

	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	for (y = 0; y < 128; y++)
	for (x = 0; x < 128; x++) {
	tex[(x + y * 128) * 3 + 0] = ((x % (128 / 4)) < (128 / 8)) ? 255 : 0;
	tex[(x + y * 128) * 3 + 1] = ((y % (128 / 4)) < (128 / 8)) ? 255 : 0;
	tex[(x + y * 128) * 3 + 2] = x;
	}

	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	if ((gluerr = gluBuild2DMipmaps(GL_TEXTURE_2D, 3, 128, 128, GL_RGB,
	GL_UNSIGNED_BYTE, (GLvoid *) (&tex[0])))) {
	fprintf(stderr, "GLULib%s\n", (char *) gluErrorString(gluerr));
	exit(-1);
	}

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
	GL_LINEAR_MIPMAP_NEAREST);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glEnable(GL_TEXTURE_2D);

	glClearColor(0.0, 0.1, 1.0, 0.0);
	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
	}

	static int
	test04(int size, int num)
	{
	int x, y, z;

	glBegin(GL_TRIANGLES);
	for (y = 0; y < num; y++)
	for (x = 0; x < size; x += 5) {
	z = num * size - (y * size + x);
	glTexCoord2f(1.0, 1.0);
	glColor3f(1.0, 0.0, 0.0);
	glVertex3i(0, x, z);

	glTexCoord2f(0.0, 1.0);
	glColor3f(0.0, 1.0, 0.0);
	glVertex3i(size - 1 - x, 0, z);

	glTexCoord2f(1.0, 0.0);
	glColor3f(0.0, 0.0, 1.0);
	glVertex3i(x, size - 1 - x, z);
	}
	glEnd();

	return num * size / 5;
	}

	/***************************************************************************/

	static void
	init_test05(void)
	{
	int x, y;
	GLubyte tex[128 * 128 * 3];
	GLenum gluerr;

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(-0.5, 639.5, -0.5, 479.5, -1.0, 1.0);

	glMatrixMode(GL_MODELVIEW);

	glShadeModel(GL_SMOOTH);
	glEnable(GL_DEPTH_TEST);

	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	for (y = 0; y < 128; y++)
	for (x = 0; x < 128; x++) {
	tex[(x + y * 128) * 3 + 0] = ((x % (128 / 4)) < (128 / 8)) ? 255 : 0;
	tex[(x + y * 128) * 3 + 1] = ((y % (128 / 4)) < (128 / 8)) ? 255 : 0;
	tex[(x + y * 128) * 3 + 2] = x;
	}

	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	if ((gluerr = gluBuild2DMipmaps(GL_TEXTURE_2D, 3, 128, 128, GL_RGB,
	GL_UNSIGNED_BYTE, (GLvoid *) (&tex[0])))) {
	fprintf(stderr, "GLULib%s\n", (char *) gluErrorString(gluerr));
	exit(-1);
	}

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
	GL_LINEAR_MIPMAP_NEAREST);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glEnable(GL_TEXTURE_2D);

	glDepthFunc(GL_ALWAYS);

	glClearColor(0.0, 0.1, 1.0, 0.0);
	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
	}

	static int
	test05(int size, int num)
	{
	int y;
	float v0[3], v1[3], v2[3], v3[3];
	float cv0[3], cv1[3], cv2[3], cv3[3];
	float tv0[3], tv1[3], tv2[3], tv3[3];

	v0[0] = 320 - size / 2;
	v0[1] = 240 - size / 2;
	v0[2] = 0.0;
	v1[0] = 320 + size / 2;
	v1[1] = 240 - size / 2;
	v1[2] = 0.0;
	v2[0] = 320 - size / 2;
	v2[1] = 240 + size / 2;
	v2[2] = 0.0;
	v3[0] = 320 + size / 2;
	v3[1] = 240 + size / 2;
	v3[2] = 0.0;
	cv0[0] = 1.0;
	cv0[1] = 0.0;
	cv0[2] = 0.0;
	cv1[0] = 1.0;
	cv1[1] = 1.0;
	cv1[2] = 0.0;
	cv2[0] = 1.0;
	cv2[1] = 0.0;
	cv2[2] = 1.0;
	cv3[0] = 1.0;
	cv3[1] = 1.0;
	cv3[2] = 1.0;
	tv0[0] = 0.0;
	tv0[1] = 0.0;
	tv0[2] = 0.0;
	tv1[0] = 1.0;
	tv1[1] = 0.0;
	tv1[2] = 0.0;
	tv2[0] = 0.0;
	tv2[1] = 1.0;
	tv2[2] = 0.0;
	tv3[0] = 1.0;
	tv3[1] = 1.0;
	tv3[2] = 0.0;

	glBegin(GL_TRIANGLE_STRIP);
	for (y = 0; y < num; y++) {
	glColor3fv(cv0);
	glTexCoord2fv(tv0);
	glVertex3fv(v0);

	glColor3fv(cv1);
	glTexCoord2fv(tv1);
	glVertex3fv(v1);

	glColor3fv(cv2);
	glTexCoord2fv(tv2);
	glVertex3fv(v2);

	glColor3fv(cv3);
	glTexCoord2fv(tv3);
	glVertex3fv(v3);
	}
	glEnd();

	return 4 * num - 2;
	}

	/***************************************************************************/

	static void
	init_test06(void)
	{
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluOrtho2D(-0.5, 639.5, -0.5, 479.5);
	glMatrixMode(GL_MODELVIEW);

	glShadeModel(GL_SMOOTH);
	glEnable(GL_DEPTH_TEST);

	glClearColor(0.0, 0.1, 1.0, 0.0);
	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
	}

	static int
	test06(int size, int num)
	{
	int y;

	for (y = 0; y < num; y++) {
	glClearColor(y / (float) num, 0.1, 1.0, 0.0);
	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
	}

	return num;
	}

	/***************************************************************************/

	#define BMARKS_TIME 5.0

	#define NUM_BMARKS 6

	/* 554 ~= sqrt(640480) /

	static benchmark bmarks[NUM_BMARKS] = {
	{"Simple Points", "Pnts", init_test01, test01, 0, 0,
	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
	{"Smooth Lines", "Lins", init_test02, test02, 1, 5,
	{480, 250, 100, 50, 25, 0, 0, 0, 0, 0}},
	{"ZSmooth Triangles", "Tris", init_test03, test03, 1, 5,
	{480, 250, 100, 50, 25, 0, 0, 0, 0, 0}},
	{"ZSmooth Tex Blend Triangles", "Tris", init_test04, test04, 1, 5,
	{480, 250, 100, 50, 25, 0, 0, 0, 0, 0}},
	{"ZSmooth Tex Blend TMesh Triangles", "Tris", init_test05, test05, 2, 8,
	{400, 250, 100, 50, 25, 10, 5, 2, 0, 0}},
	{"Color/Depth Buffer Clears", "Clrs", init_test06, test06, 3, 0,
	{554, 0, 0, 0, 0, 0, 0, 0, 0, 0}}
	};

	/***************************************************************************/

	static void
	dotest0param(benchmark * bmark)
	{
	float stime, etime, dtime, tottime, maxtime, mintime;
	int num, numelem, calibnum, j;

	glPushAttrib(GL_ALL_ATTRIB_BITS);
	bmark->init();

	stime = glutGet(GLUT_ELAPSED_TIME);

	dtime = 0.0;
	calibnum = 0;
	while (dtime < 2.0) {
	bmark->run(0, 1);
	glFinish();
	etime = glutGet(GLUT_ELAPSED_TIME);
	dtime = (etime - stime) / 1000.0;
	calibnum++;
	}
	glPopAttrib();

	fprintf(stderr, "Elapsed time for the calibration test (%d): %f\n",
	calibnum, dtime);

	num = (int) ((BMARKS_TIME / dtime) * calibnum);

	if (num < 1)
	num = 1;

	fprintf(stderr, "Selected number of benchmark iterations: %d\n", num);

	mintime = HUGE_VAL;
	maxtime = -HUGE_VAL;

	for (tottime = 0.0, j = 0; j < 5; j++) {
	glPushAttrib(GL_ALL_ATTRIB_BITS);
	bmark->init();

	stime = glutGet(GLUT_ELAPSED_TIME);
	numelem = bmark->run(0, num);
	glFinish();
	etime = glutGet(GLUT_ELAPSED_TIME);

	glPopAttrib();

	dtime = (etime - stime) / 1000.0;
	tottime += dtime;

	fprintf(stderr, "Elapsed time for run %d: %f\n", j, dtime);

	if (dtime < mintime)
	mintime = dtime;
	if (dtime > maxtime)
	maxtime = dtime;
	}

	tottime -= mintime + maxtime;

	fprintf(stdout, "%s\n%f %s/sec", bmark->name, numelem / (tottime / 3.0),
	bmark->unit);

	if (bmark->type == 3)
	fprintf(stdout, ", MPixel Fill/sec: %f\n\n",
	(numelem * bmark->size[0] * (float) bmark->size[0]) /
	(1000000.0 * tottime / 3.0));
	else
	fprintf(stdout, "\n\n");
	}

	/***************************************************************************/

	static void
	dotest1param(benchmark * bmark)
	{
	float stime, etime, dtime, tottime, maxtime, mintime;
	int num, numelem, calibnum, j, k;

	fprintf(stdout, "%s\n", bmark->name);

	for (j = 0; j < bmark->numsize; j++) {
	fprintf(stderr, "Current size: %d\n", bmark->size[j]);

	glPushAttrib(GL_ALL_ATTRIB_BITS);
	bmark->init();

	stime = glutGet(GLUT_ELAPSED_TIME);

	dtime = 0.0;
	calibnum = 0;
	while (dtime < 2.0) {
	bmark->run(bmark->size[j], 1);
	glFinish();
	etime = glutGet(GLUT_ELAPSED_TIME);
	dtime = (etime - stime) / 1000.0;
	calibnum++;
	}
	glPopAttrib();

	fprintf(stderr, "Elapsed time for the calibration test (%d): %f\n",
	calibnum, dtime);

	num = (int) ((BMARKS_TIME / dtime) * calibnum);

	if (num < 1)
	num = 1;

	fprintf(stderr, "Selected number of benchmark iterations: %d\n", num);

	mintime = HUGE_VAL;
	maxtime = -HUGE_VAL;

	for (numelem = 1, tottime = 0.0, k = 0; k < 5; k++) {
	glPushAttrib(GL_ALL_ATTRIB_BITS);
	bmark->init();

	stime = glutGet(GLUT_ELAPSED_TIME);
	numelem = bmark->run(bmark->size[j], num);
	glFinish();
	etime = glutGet(GLUT_ELAPSED_TIME);

	glPopAttrib();

	dtime = (etime - stime) / 1000.0;
	tottime += dtime;

	fprintf(stderr, "Elapsed time for run %d: %f\n", k, dtime);

	if (dtime < mintime)
	mintime = dtime;
	if (dtime > maxtime)
	maxtime = dtime;
	}

	tottime -= mintime + maxtime;

	fprintf(stdout, "SIZE=%03d => %f %s/sec", bmark->size[j],
	numelem / (tottime / 3.0), bmark->unit);
	if (bmark->type == 2)
	fprintf(stdout, ", MPixel Fill/sec: %f\n",
	(numelem * bmark->size[j] * bmark->size[j] / 2) /
	(1000000.0 * tottime / 3.0));
	else
	fprintf(stdout, "\n");
	}

	fprintf(stdout, "\n\n");
	}

	/***************************************************************************/

	static void
	display(void)
	{
	int i;

	if (frontbuffer)
	glDrawBuffer(GL_FRONT);
	else
	glDrawBuffer(GL_BACK);

	for (i = 0; i < NUM_BMARKS; i++) {
	fprintf(stderr, "Benchmark: %d\n", i);

	switch (bmarks[i].type) {
	case 0:
	case 3:
	dotest0param(&bmarks[i]);
	break;
	case 1:
	case 2:
	dotest1param(&bmarks[i]);
	break;
	}
	}

	exit(0);
	}

	int
	main(int ac, char **av)
	{
	fprintf(stderr, "GLTest v1.0\nWritten by David Bucciarelli\n");

	if (ac == 2)
	frontbuffer = 0;

	glutInit(&ac, av);
	glutInitDisplayMode(GLUT_DOUBLE \| GLUT_RGB \| GLUT_DEPTH);
	glutInitWindowPosition(0, 0);
	glutInitWindowSize(640, 480);
	glutCreateWindow("OpenGL/Mesa Performances");
	glutDisplayFunc(display);
	glutMainLoop();

	return 0;
	}