← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/mesa-demos/oneiric

« back to all changes in this revision

Viewing changes to src/demos/trispd.c

  • Committer: Bazaar Package Importer
  • Author(s): Christopher James Halse Rogers
  • Date: 2010-09-27 16:18:27 UTC
  • Revision ID: james.westby@ubuntu.com-20100927161827-1yfgolc1oy9sjhi8
Tags: upstream-8.0.1
Import upstream version 8.0.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/demos/trispd.c
 
1
 
 
2
/*
 
3
 * Simple GLUT program to measure triangle strip rendering speed.
 
4
 * Brian Paul  February 15, 1997  This file is in the public domain.
 
5
 */
 
6
 
 
7
#include <stdio.h>
 
8
#include <stdlib.h>
 
9
#include <math.h>
 
10
#include <string.h>
 
11
#include <GL/glut.h>
 
12
 
 
13
 
 
14
static float MinPeriod = 2.0;   /* 2 seconds */
 
15
static float Width = 400.0;
 
16
static float Height = 400.0;
 
17
static int Loops = 1;
 
18
static int Size = 50;
 
19
static int Texture = 0;
 
20
 
 
21
 
 
22
 
 
23
static void Idle( void )
 
24
{
 
25
   glutPostRedisplay();
 
26
}
 
27
 
 
28
 
 
29
static void Display( void )
 
30
{
 
31
   float x, y;
 
32
   float xStep;
 
33
   float yStep;
 
34
   double t0, t1;
 
35
   double triRate;
 
36
   double pixelRate;
 
37
   int triCount;
 
38
   int i;
 
39
   float red[3] = { 1.0, 0.0, 0.0 };
 
40
   float blue[3] = { 0.0, 0.0, 1.0 };
 
41
 
 
42
   xStep = yStep = sqrt( 2.0 * Size );
 
43
 
 
44
   glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 
45
 
 
46
   triCount = 0;
 
47
   t0 = glutGet(GLUT_ELAPSED_TIME) * 0.001;
 
48
   if (Texture) {
 
49
      float uStep = xStep / Width;
 
50
      float vStep = yStep / Height;
 
51
      float u, v;
 
52
      for (i=0; i<Loops; i++) {
 
53
         for (y=1.0, v=0.0f; y<Height-yStep; y+=yStep, v+=vStep) {
 
54
            glBegin(GL_TRIANGLE_STRIP);
 
55
            for (x=1.0, u=0.0f; x<Width; x+=xStep, u+=uStep) {
 
56
               glColor3fv(red);
 
57
               glTexCoord2f(u, v);          
 
58
               glVertex2f(x, y);
 
59
               glColor3fv(blue);
 
60
               glTexCoord2f(u, v+vStep);
 
61
               glVertex2f(x, y+yStep);
 
62
               triCount += 2;
 
63
            }
 
64
            glEnd();
 
65
            triCount -= 2;
 
66
         }
 
67
      }
 
68
   }
 
69
   else {
 
70
      for (i=0; i<Loops; i++) {
 
71
         for (y=1.0; y<Height-yStep; y+=yStep) {
 
72
            glBegin(GL_TRIANGLE_STRIP);
 
73
            for (x=1.0; x<Width; x+=xStep) {
 
74
               glColor3fv(red);
 
75
               glVertex2f(x, y);
 
76
               glColor3fv(blue);
 
77
               glVertex2f(x, y+yStep);
 
78
               triCount += 2;
 
79
            }
 
80
            glEnd();
 
81
            triCount -= 2;
 
82
         }
 
83
      }
 
84
   }
 
85
   glFinish();
 
86
   t1 = glutGet(GLUT_ELAPSED_TIME) * 0.001;
 
87
   
 
88
   if (t1-t0 < MinPeriod) {
 
89
      /* Next time draw more triangles to get longer elapsed time */
 
90
      Loops *= 2;
 
91
      return;
 
92
   }
 
93
 
 
94
   triRate = triCount / (t1-t0);
 
95
   pixelRate = triRate * Size;
 
96
   printf("Rate: %d tri in %gs = %g tri/s  %d pixels/s\n",
 
97
          triCount, t1-t0, triRate, (int)pixelRate);
 
98
 
 
99
   glutSwapBuffers();
 
100
}
 
101
 
 
102
 
 
103
static void Reshape( int width, int height )
 
104
{
 
105
   Width = width;
 
106
   Height = height;
 
107
   glViewport( 0, 0, width, height );
 
108
   glMatrixMode( GL_PROJECTION );
 
109
   glLoadIdentity();
 
110
   glOrtho(0.0, width, 0.0, height, -1.0, 1.0);
 
111
   glMatrixMode( GL_MODELVIEW );
 
112
   glLoadIdentity();
 
113
}
 
114
 
 
115
 
 
116
static void Key( unsigned char key, int x, int y )
 
117
{
 
118
   (void) x;
 
119
   (void) y;
 
120
   switch (key) {
 
121
      case 27:
 
122
         exit(0);
 
123
         break;
 
124
   }
 
125
   glutPostRedisplay();
 
126
}
 
127
 
 
128
 
 
129
static void LoadTex(int comp, int filter)
 
130
{
 
131
   GLubyte *pixels;
 
132
   int x, y;
 
133
   pixels = (GLubyte *) malloc(4*256*256);
 
134
   for (y = 0; y < 256; ++y)
 
135
      for (x = 0; x < 256; ++x) {
 
136
         pixels[(y*256+x)*4+0] = (int)(128.5 + 127.0 * cos(0.024544 * x));
 
137
         pixels[(y*256+x)*4+1] = 255;
 
138
         pixels[(y*256+x)*4+2] = (int)(128.5 + 127.0 * cos(0.024544 * y));
 
139
         pixels[(y*256+x)*4+3] = 255;
 
140
      }
 
141
   glEnable(GL_TEXTURE_2D);
 
142
   glTexImage2D(GL_TEXTURE_2D, 0, comp, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
 
143
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
 
144
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
 
145
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 
146
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
147
   glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 
148
   printf("Texture: GL_MODULATE, %d comps, %s\n", comp, filter == GL_NEAREST ? "GL_NEAREST" : "GL_LINEAR");
 
149
}
 
150
 
 
151
 
 
152
static void Init( int argc, char *argv[] )
 
153
{
 
154
   GLint shade;
 
155
   GLint rBits, gBits, bBits;
 
156
   int filter = GL_NEAREST, comp = 3;
 
157
 
 
158
   int i;
 
159
   for (i=1; i<argc; i++) {
 
160
      if (strcmp(argv[i],"-dither")==0)
 
161
         glDisable(GL_DITHER);
 
162
      else if (strcmp(argv[i],"+dither")==0)
 
163
         glEnable(GL_DITHER);
 
164
      else if (strcmp(argv[i],"+smooth")==0)
 
165
         glShadeModel(GL_SMOOTH);
 
166
      else if (strcmp(argv[i],"+flat")==0)
 
167
         glShadeModel(GL_FLAT);
 
168
      else if (strcmp(argv[i],"+depth")==0)
 
169
         glEnable(GL_DEPTH_TEST);
 
170
      else if (strcmp(argv[i],"-depth")==0)
 
171
         glDisable(GL_DEPTH_TEST);
 
172
      else if (strcmp(argv[i],"-size")==0) {
 
173
         Size = atoi(argv[i+1]);
 
174
         i++;
 
175
      }
 
176
      else if (strcmp(argv[i],"-texture")==0)
 
177
         Texture = 0;
 
178
      else if (strcmp(argv[i],"+texture")==0)
 
179
         Texture = 1;
 
180
      else if (strcmp(argv[i],"-linear")==0)
 
181
         filter = GL_NEAREST;
 
182
      else if (strcmp(argv[i],"+linear")==0)
 
183
         filter = GL_LINEAR;
 
184
      else if (strcmp(argv[i],"-persp")==0)
 
185
         glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
 
186
      else if (strcmp(argv[i],"+persp")==0)
 
187
         glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
 
188
      else if (strcmp(argv[i],"-comp")==0) {
 
189
         comp = atoi(argv[i+1]);
 
190
         i++;
 
191
      }
 
192
      else
 
193
         printf("Unknown option: %s\n", argv[i]);
 
194
   }
 
195
 
 
196
   glGetIntegerv(GL_SHADE_MODEL, &shade);
 
197
 
 
198
   printf("Dither: %s\n", glIsEnabled(GL_DITHER) ? "on" : "off");
 
199
   printf("ShadeModel: %s\n", (shade==GL_FLAT) ? "flat" : "smooth");
 
200
   printf("DepthTest: %s\n", glIsEnabled(GL_DEPTH_TEST) ? "on" : "off");
 
201
   printf("Size: %d pixels\n", Size);
 
202
 
 
203
   if (Texture)
 
204
      LoadTex(comp, filter);
 
205
 
 
206
   glGetIntegerv(GL_RED_BITS, &rBits);
 
207
   glGetIntegerv(GL_GREEN_BITS, &gBits);
 
208
   glGetIntegerv(GL_BLUE_BITS, &bBits);
 
209
   printf("RedBits: %d  GreenBits: %d  BlueBits: %d\n", rBits, gBits, bBits);
 
210
}
 
211
 
 
212
 
 
213
static void Help( const char *program )
 
214
{
 
215
   printf("%s options:\n", program);
 
216
   printf("  +/-dither      enable/disable dithering\n");
 
217
   printf("  +/-depth       enable/disable depth test\n");
 
218
   printf("  +flat          flat shading\n");
 
219
   printf("  +smooth        smooth shading\n");
 
220
   printf("  -size pixels   specify pixels/triangle\n");
 
221
   printf("  +/-texture     enable/disable texture\n");
 
222
   printf("  -comp n        texture format\n");
 
223
   printf("  +/-linear      bilinear texture filter\n");
 
224
   printf("  +/-persp       perspective correction hint\n");
 
225
}
 
226
 
 
227
 
 
228
int main( int argc, char *argv[] )
 
229
{
 
230
   glutInitWindowSize( (int) Width, (int) Height );
 
231
   glutInit( &argc, argv );
 
232
   glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH );
 
233
   glutCreateWindow( argv[0] );
 
234
 
 
235
   printf("For options:  %s -help\n", argv[0]);
 
236
   if (argc==2 && strcmp(argv[1],"-help")==0) {
 
237
      Help(argv[0]);
 
238
      return 0;
 
239
   }
 
240
 
 
241
   Init( argc, argv );
 
242
 
 
243
   glutReshapeFunc( Reshape );
 
244
   glutKeyboardFunc( Key );
 
245
   glutDisplayFunc( Display );
 
246
   glutIdleFunc( Idle );
 
247
 
 
248
   glutMainLoop();
 
249
   return 0;
 
250
}