开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
gltest.c
资源名称：glut23-src.zip　[点击查看]
上传用户：xk288cn
上传日期：2007-05-28
资源大小：4876k
文件大小：12k
源码类别：

GIS编程

开发平台：

Visual C++

gltest.c：源码内容
  1. /*
  2.  * This program is under the GNU GPL.
  3.  * Use at your own risk.
  4.  *
  5.  * written by David Bucciarelli (tech.hmw@plus.it)
  6.  *            Humanware s.r.l.
  7.  */
  9. #include <stdlib.h>
  10. #include <stdio.h>
  11. #include <string.h>
  12. #include <math.h>
  13. #include <GL/glut.h>
  15. typedef struct {
  16.   char *name;
  17.   char *unit;
  18.   void (*init)(void);
  19.   int (*run)(int, int);
  20.   int type;
  21.   int numsize;
  22.   int size[10];
  23. } benchmark;
  25. static int frontbuffer=1;
  27. /***************************************************************************/
  29. static void init_test01(void)
  30. {
  31.   glMatrixMode(GL_PROJECTION);
  32.   glLoadIdentity();
  33.   gluOrtho2D(-0.5,639.5,-0.5,479.5);
  34.   glMatrixMode(GL_MODELVIEW);
  36.   glShadeModel(GL_FLAT);
  37.   glDisable(GL_DEPTH_TEST);
  39.   glClearColor(0.0,0.1,1.0,0.0);
  40.   glClear(GL_COLOR_BUFFER_BIT);
  41.   glColor3f(1.0,0.0,0.0);
  42. }
  44. /* ARGSUSED */
  45. static int test01(int size, int num)
  46. {
  47.   int x,y;
  49.   glBegin(GL_POINTS);
  50.   for(y=0;y<num;y++)
  51.     for(x=0;x<480;x++)
  52.       glVertex2i(x,x);
  53.   glEnd();
  55.   return 480*num;
  56. }
  58. /***************************************************************************/
  60. static void init_test02(void)
  61. {
  62.   glMatrixMode(GL_PROJECTION);
  63.   glLoadIdentity();
  64.   gluOrtho2D(-0.5,639.5,-0.5,479.5);
  65.   glMatrixMode(GL_MODELVIEW);
  67.   glShadeModel(GL_SMOOTH);
  68.   glDisable(GL_DEPTH_TEST);
  70.   glClearColor(0.0,0.1,1.0,0.0);
  71.   glClear(GL_COLOR_BUFFER_BIT);
  72. }
  74. static int test02(int size, int num)
  75. {
  76.   int x,y;
  78.   glBegin(GL_LINES);
  79.   for(y=0;y<num;y++)
  80.     for(x=0;x<size;x++) {
  81.       glColor3f(0.0,1.0,y/(float)num);
  82.       glVertex2i(0,size-1);
  83.       glColor3f(1.0,0.0,x/(float)size);
  84.       glVertex2i(x,x);
  85.     }
  86.   glEnd();
  88.   return num*size;
  89. }
  91. /***************************************************************************/
  93. static void init_test03(void)
  94. {
  95.   glMatrixMode(GL_PROJECTION);
  96.   glLoadIdentity();
  97.   glOrtho(-0.5,639.5,-0.5,479.5,1.0,-1000.0*480.0);
  98.   glMatrixMode(GL_MODELVIEW);
  100.   glShadeModel(GL_SMOOTH);
  101.   glEnable(GL_DEPTH_TEST);
  103.   glClearColor(0.0,0.1,1.0,0.0);
  104.   glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  105. }
  107. static int test03(int size, int num)
  108. {
  109.   int x,y,z;
  111.   glBegin(GL_TRIANGLES);
  112.   for(y=0;y<num;y++)
  113.     for(x=0;x<size;x+=5) {
  114.       z=num*size-(y*size+x);
  115.       glColor3f(0.0,1.0,0.0);
  116.       glVertex3i(0,x,z);
  118.       glColor3f(1.0,0.0,x/(float)size);
  119.       glVertex3i(size-1-x,0,z);
  121.       glColor3f(1.0,x/(float)size,0.0);
  122.       glVertex3i(x,size-1-x,z);
  123.     }
  124.   glEnd();
  126.   return size*num/5;
  127. }
  129. /***************************************************************************/
  131. static void init_test04(void)
  132. {
  133.   int x,y;
  134.   GLubyte tex[128*128*3];
  135.   GLenum gluerr;
  137.   glMatrixMode(GL_PROJECTION);
  138.   glLoadIdentity();
  139.   glOrtho(-0.5,639.5,-0.5,479.5,1.0,-1000.0*480.0);
  141.   glMatrixMode(GL_MODELVIEW);
  143.   glShadeModel(GL_SMOOTH);
  144.   glEnable(GL_DEPTH_TEST);
  146.   glEnable(GL_BLEND);
  147.   glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  149.   for(y=0;y<128;y++)
  150.     for(x=0;x<128;x++) {
  151.       tex[(x+y*128)*3+0]=((x % (128/4)) < (128/8)) ? 255 : 0;
  152.       tex[(x+y*128)*3+1]=((y % (128/4)) < (128/8)) ? 255 : 0;
  153.       tex[(x+y*128)*3+2]=x;
  154.     }
  156.   glPixelStorei(GL_UNPACK_ALIGNMENT,1);
  157.   if((gluerr=gluBuild2DMipmaps(GL_TEXTURE_2D,3,128,128,GL_RGB,
  158.        GL_UNSIGNED_BYTE,(GLvoid *)(&tex[0])))) {
  159.     fprintf(stderr,"GLULib%sn",gluErrorString(gluerr));
  160.     exit(-1);
  161.   }
  163.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
  164.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
  166.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST_MIPMAP_LINEAR);
  167.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  169.   glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
  170.   glEnable(GL_TEXTURE_2D);
  172.   glClearColor(0.0,0.1,1.0,0.0);
  173.   glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  174. }
  176. static int test04(int size, int num)
  177. {
  178.   int x,y,z;
  180.   glBegin(GL_TRIANGLES);
  181.   for(y=0;y<num;y++)
  182.     for(x=0;x<size;x+=5) {
  183.       z=num*size-(y*size+x);
  184.       glTexCoord2f(1.0,1.0);
  185.       glColor3f(1.0,0.0,0.0);
  186.       glVertex3i(0,x,z);
  188.       glTexCoord2f(0.0,1.0);
  189.       glColor3f(0.0,1.0,0.0);
  190.       glVertex3i(size-1-x,0,z);
  192.       glTexCoord2f(1.0,0.0);
  193.       glColor3f(0.0,0.0,1.0);
  194.       glVertex3i(x,size-1-x,z);
  195.     }
  196.   glEnd();
  198.   return num*size/5;
  199. }
  201. /***************************************************************************/
  203. static void init_test05(void)
  204. {
  205.   int x,y;
  206.   GLubyte tex[128*128*3];
  207.   GLenum gluerr;
  209.   glMatrixMode(GL_PROJECTION);
  210.   glLoadIdentity();
  211.   glOrtho(-0.5,639.5,-0.5,479.5,-1.0,1.0);
  213.   glMatrixMode(GL_MODELVIEW);
  215.   glShadeModel(GL_SMOOTH);
  216.   glEnable(GL_DEPTH_TEST);
  218.   glEnable(GL_BLEND);
  219.   glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  221.   for(y=0;y<128;y++)
  222.     for(x=0;x<128;x++) {
  223.       tex[(x+y*128)*3+0]=((x % (128/4)) < (128/8)) ? 255 : 0;
  224.       tex[(x+y*128)*3+1]=((y % (128/4)) < (128/8)) ? 255 : 0;
  225.       tex[(x+y*128)*3+2]=x;
  226.     }
  228.   glPixelStorei(GL_UNPACK_ALIGNMENT,1);
  229.   if((gluerr=gluBuild2DMipmaps(GL_TEXTURE_2D,3,128,128,GL_RGB,
  230.        GL_UNSIGNED_BYTE,(GLvoid *)(&tex[0])))) {
  231.     fprintf(stderr,"GLULib%sn",gluErrorString(gluerr));
  232.     exit(-1);
  233.   }
  235.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
  236.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
  238.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST_MIPMAP_LINEAR);
  239.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  241.   glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
  242.   glEnable(GL_TEXTURE_2D);
  244.   glDepthFunc(GL_ALWAYS);
  246.   glClearColor(0.0,0.1,1.0,0.0);
  247.   glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  248. }
  250. static int test05(int size, int num)
  251. {
  252.   int y;
  253.   float v0[3];
  254.   float v1[3];
  255.   float v2[3];
  256.   float v3[3];
  257.   float cv0[3]={1.0,0.0,0.0};
  258.   float cv1[3]={1.0,1.0,0.0};
  259.   float cv2[3]={1.0,0.0,1.0};
  260.   float cv3[3]={1.0,1.0,1.0};
  261.   float tv0[3]={0.0,0.0};
  262.   float tv1[3]={1.0,0.0};
  263.   float tv2[3]={0.0,1.0};
  264.   float tv3[3]={1.0,1.0};
  266.   v0[0] = 320-size/2;
  267.   v0[1] = 240-size/2;
  268.   v0[2] = 0.0;
  269.   v1[0] = 320+size/2;
  270.   v1[1] = 240-size/2;
  271.   v1[2] = 0.0;
  272.   v2[0] = 320-size/2;
  273.   v2[1] = 240+size/2;
  274.   v2[2] = 0.0;
  275.   v3[0] = 320+size/2;
  276.   v3[1] = 240+size/2;
  277.   v3[2] = 0.0;
  279.   glBegin(GL_TRIANGLE_STRIP);
  280.   for(y=0;y<num;y++) {
  281.     glColor3fv(cv0);
  282.     glTexCoord2fv(tv0);
  283.     glVertex3fv(v0);
  285.     glColor3fv(cv1);
  286.     glTexCoord2fv(tv1);
  287.     glVertex3fv(v1);
  289.     glColor3fv(cv2);
  290.     glTexCoord2fv(tv2);
  291.     glVertex3fv(v2);
  293.     glColor3fv(cv3);
  294.     glTexCoord2fv(tv3);
  295.     glVertex3fv(v3);
  296.   }
  297.   glEnd();
  299.   return 4*num-2;
  300. }
  302. /***************************************************************************/
  304. static void init_test06(void)
  305. {
  306.   glMatrixMode(GL_PROJECTION);
  307.   glLoadIdentity();
  308.   gluOrtho2D(-0.5,639.5,-0.5,479.5);
  309.   glMatrixMode(GL_MODELVIEW);
  311.   glShadeModel(GL_SMOOTH);
  312.   glEnable(GL_DEPTH_TEST);
  314.   glClearColor(0.0,0.1,1.0,0.0);
  315.   glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  316. }
  318. /* ARGSUSED */
  319. static int test06(int size, int num)
  320. {
  321.   int y;
  323.   for(y=0;y<num;y++) {
  324.     glClearColor(y/(float)num,0.1,1.0,0.0);
  325.     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  326.   }
  328.   return num;
  329. }
  331. /***************************************************************************/
  333. #define BMARKS_TIME 5.0
  335. #define NUM_BMARKS 6
  337. /* 554 ~= sqrt(640*480) */
  339. static benchmark bmarks[NUM_BMARKS]={
  340.   {"Simple Points","Pnts",init_test01,test01,0,0,{0,0,0,0,0,0,0,0,0,0}},
  341.   {"Smooth Lines","Lins",init_test02,test02,1,5,{480,250,100,50,25,0,0,0,0,0}},
  342.   {"ZSmooth Triangles","Tris",init_test03,test03,1,5,{480,250,100,50,25,0,0,0,0,0}},
  343.   {"ZSmooth Tex Blend Triangles","Tris",init_test04,test04,1,5,{480,250,100,50,25,0,0,0,0,0}},
  344.   {"ZSmooth Tex Blend TMesh Triangles","Tris",init_test05,test05,2,8,{400,250,100,50,25,10,5,2,0,0}},
  345.   {"Color/Depth Buffer Clears","Clrs",init_test06,test06,3,0,{554,0,0,0,0,0,0,0,0,0}}
  346. };
  348. /***************************************************************************/
  350. static void dotest0param(benchmark *bmark)
  351. {
  352.   float stime,etime,dtime,tottime,maxtime,mintime;
  353.   int num,numelem,calibnum,j;
  355.   glPushAttrib(GL_ALL_ATTRIB_BITS);
  356.   bmark->init();
  358.   stime=glutGet(GLUT_ELAPSED_TIME);
  360.   dtime=0.0;
  361.   calibnum=0;
  362.   while(dtime<2.0) {
  363.     bmark->run(0,1);
  364.     glFinish();
  365.     etime=glutGet(GLUT_ELAPSED_TIME);
  366.     dtime=(etime-stime)/1000.0;
  367.     calibnum++;
  368.   }
  369.   glPopAttrib();
  371.   fprintf(stderr,"Elapsed time for the calibration test (%d): %fn",calibnum,dtime);
  373.   num=(int)((BMARKS_TIME/dtime)*calibnum);
  375.   if(num<1)
  376.     num=1;
  378.   fprintf(stderr,"Selected number of benchmark iterations: %dn",num);
  380.   mintime=HUGE_VAL;
  381.   maxtime=-HUGE_VAL;
  383.   for(tottime=0.0,j=0;j<5;j++) {
  384.     glPushAttrib(GL_ALL_ATTRIB_BITS);
  385.     bmark->init();
  387.     stime=glutGet(GLUT_ELAPSED_TIME);
  388.     numelem=bmark->run(0,num);
  389.     glFinish();
  390.     etime=glutGet(GLUT_ELAPSED_TIME);
  392.     glPopAttrib();
  394.     dtime=(etime-stime)/1000.0;
  395.     tottime+=dtime;
  397.     fprintf(stderr,"Elapsed time for run %d: %fn",j,dtime);
  399.     if(dtime<mintime)
  400.       mintime=dtime;
  401.     if(dtime>maxtime)
  402.       maxtime=dtime;
  403.   }
  405.   tottime-=mintime+maxtime;
  407.   fprintf(stdout,"%sn%f %s/sec",bmark->name,numelem/(tottime/3.0),bmark->unit);
  409.   if(bmark->type==3)
  410.     fprintf(stdout,", MPixel Fill/sec: %fnn",
  411.     (numelem*bmark->size[0]*(float)bmark->size[0])/(1000000.0*tottime/3.0));
  412.   else
  413.     fprintf(stdout,"nn");
  414. }
  416. /***************************************************************************/
  418. static void dotest1param(benchmark *bmark)
  419. {
  420.   float stime,etime,dtime,tottime,maxtime,mintime;
  421.   int num,numelem,calibnum,j,k;
  423.   fprintf(stdout,"%sn",bmark->name);
  425.   for(j=0;j<bmark->numsize;j++) {
  426.     fprintf(stderr,"Current size: %dn",bmark->size[j]);
  428.     glPushAttrib(GL_ALL_ATTRIB_BITS);
  429.     bmark->init();
  431.     stime=glutGet(GLUT_ELAPSED_TIME);
  433.     dtime=0.0;
  434.     calibnum=0;
  435.     while(dtime<2.0) {
  436.       bmark->run(bmark->size[j],1);
  437.       glFinish();
  438.       etime=glutGet(GLUT_ELAPSED_TIME);
  439.       dtime=(etime-stime)/1000.0;
  440.       calibnum++;
  441.     }
  442.     glPopAttrib();
  444.     fprintf(stderr,"Elapsed time for the calibration test (%d): %fn",calibnum,dtime);
  446.     num=(int)((BMARKS_TIME/dtime)*calibnum);
  448.     if(num<1)
  449.       num=1;
  451.     fprintf(stderr,"Selected number of benchmark iterations: %dn",num);
  453.     mintime=HUGE_VAL;
  454.     maxtime=-HUGE_VAL;
  456.     for(numelem=1,tottime=0.0,k=0;k<5;k++) {
  457.       glPushAttrib(GL_ALL_ATTRIB_BITS);
  458.       bmark->init();
  460.       stime=glutGet(GLUT_ELAPSED_TIME);
  461.       numelem=bmark->run(bmark->size[j],num);
  462.       glFinish();
  463.       etime=glutGet(GLUT_ELAPSED_TIME);
  465.       glPopAttrib();
  467.       dtime=(etime-stime)/1000.0;
  468.       tottime+=dtime;
  470.       fprintf(stderr,"Elapsed time for run %d: %fn",k,dtime);
  472.       if(dtime<mintime)
  473. mintime=dtime;
  474.       if(dtime>maxtime)
  475. maxtime=dtime;
  476.     }
  478.     tottime-=mintime+maxtime;
  480.     fprintf(stdout,"SIZE=%03d => %f %s/sec",bmark->size[j],numelem/(tottime/3.0),bmark->unit);
  481.     if(bmark->type==2)
  482.       fprintf(stdout,", MPixel Fill/sec: %fn",
  483.       (numelem*bmark->size[j]*bmark->size[j]/2)/(1000000.0*tottime/3.0));
  484.     else
  485.       fprintf(stdout,"n");
  486.   }
  488.   fprintf(stdout,"nn");
  489. }
  491. /***************************************************************************/
  493. static void display(void)
  494. {
  495.   int i;
  497.   if(frontbuffer)
  498.     glDrawBuffer(GL_FRONT);
  499.   else
  500.     glDrawBuffer(GL_BACK);
  502.   for(i=0;i<NUM_BMARKS;i++) {
  503.     fprintf(stderr,"Benchmark: %dn",i);
  505.     switch(bmarks[i].type) {
  506.     case 0:
  507.     case 3:
  508.       dotest0param(&bmarks[i]);
  509.       break;
  510.     case 1:
  511.     case 2:
  512.       dotest1param(&bmarks[i]);
  513.       break;
  514.     }
  515.   }
  517.   exit(0);
  518. }
  520. int main(int ac, char **av)
  521. {
  522.   fprintf(stderr,"GLTest v1.0nWritten by David Bucciarellin");
  524.   if(ac==2)
  525.     frontbuffer=0;
  527.   glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
  528.   glutInitWindowPosition(0,0);
  529.   glutInitWindowSize(640,480);
  530.   glutCreateWindow("OpenGL/Mesa Performances");
  531.   glutDisplayFunc(display);
  532.   glutMainLoop();
  534.   return 0;             /* ANSI C requires main to return int. */
  535. }