← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mesa-glw/quantal

« back to all changes in this revision

Viewing changes to progs/demos/drawpix.c

  • Committer: Bazaar Package Importer
  • Author(s): Morten Kjeldgaard
  • Date: 2008-05-06 16:19:15 UTC
  • Revision ID: james.westby@ubuntu.com-20080506161915-uynz7nftmfixu6bq
Tags: upstream-7.0.3
Import upstream version 7.0.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
progs/demos/drawpix.c
 
1
 
 
2
/*
 
3
 * glDrawPixels demo/test/benchmark
 
4
 * 
 
5
 * Brian Paul   September 25, 1997  This file is in the public domain.
 
6
 */
 
7
 
 
8
#include <stdio.h>
 
9
#include <stdlib.h>
 
10
#include <math.h>
 
11
#include <string.h>
 
12
#include <GL/glut.h>
 
13
 
 
14
#include "readtex.h"
 
15
 
 
16
#define IMAGE_FILE "../images/girl.rgb"
 
17
 
 
18
static int ImgWidth, ImgHeight;
 
19
static GLenum ImgFormat;
 
20
static GLubyte *Image = NULL;
 
21
 
 
22
static int Xpos, Ypos;
 
23
static int SkipPixels, SkipRows;
 
24
static int DrawWidth, DrawHeight;
 
25
static int Scissor = 0;
 
26
static int Fog = 0;
 
27
static GLfloat Zpos = -1.0;
 
28
static float Xzoom, Yzoom;
 
29
static GLboolean DrawFront = GL_FALSE;
 
30
static GLboolean Dither = GL_TRUE;
 
31
 
 
32
 
 
33
static void Reset( void )
 
34
{
 
35
   Xpos = Ypos = 20;
 
36
   DrawWidth = ImgWidth;
 
37
   DrawHeight = ImgHeight;
 
38
   SkipPixels = SkipRows = 0;
 
39
   Scissor = 0;
 
40
   Fog = 0;
 
41
   Zpos = -1.0;
 
42
   Xzoom = Yzoom = 1.0;
 
43
}
 
44
 
 
45
 
 
46
static void Display( void )
 
47
{
 
48
   glClear( GL_COLOR_BUFFER_BIT );
 
49
 
 
50
#if 0
 
51
   glRasterPos2i(Xpos, Ypos);
 
52
#else
 
53
   /* This allows negative raster positions: */
 
54
   glRasterPos3f(0, 0, Zpos);
 
55
   glBitmap(0, 0, 0, 0, Xpos, Ypos, NULL);
 
56
#endif
 
57
 
 
58
   glPixelStorei(GL_UNPACK_SKIP_PIXELS, SkipPixels);
 
59
   glPixelStorei(GL_UNPACK_SKIP_ROWS, SkipRows);
 
60
 
 
61
   glPixelZoom( Xzoom, Yzoom );
 
62
 
 
63
   if (Scissor)
 
64
      glEnable(GL_SCISSOR_TEST);
 
65
 
 
66
   if (Fog)
 
67
      glEnable(GL_FOG);
 
68
 
 
69
   glDrawPixels(DrawWidth, DrawHeight, ImgFormat, GL_UNSIGNED_BYTE, Image);
 
70
 
 
71
   glDisable(GL_SCISSOR_TEST);
 
72
   glDisable(GL_FOG);
 
73
 
 
74
   if (DrawFront)
 
75
      glFinish();
 
76
   else
 
77
      glutSwapBuffers();
 
78
}
 
79
 
 
80
 
 
81
static void Benchmark( void )
 
82
{
 
83
   int startTime, endTime;
 
84
   int draws = 500;
 
85
   double seconds, pixelsPerSecond;
 
86
 
 
87
   printf("Benchmarking...\n");
 
88
   /* GL set-up */
 
89
   glPixelStorei(GL_UNPACK_SKIP_PIXELS, SkipPixels);
 
90
   glPixelStorei(GL_UNPACK_SKIP_ROWS, SkipRows);
 
91
   glPixelZoom( Xzoom, Yzoom );
 
92
   if (Scissor)
 
93
      glEnable(GL_SCISSOR_TEST);
 
94
   if (Fog)
 
95
      glEnable(GL_FOG);
 
96
 
 
97
   if (DrawFront)
 
98
      glDrawBuffer(GL_FRONT);
 
99
   else
 
100
      glDrawBuffer(GL_BACK);
 
101
 
 
102
   /* Run timing test */
 
103
   draws = 0;
 
104
   startTime = glutGet(GLUT_ELAPSED_TIME);
 
105
   do {
 
106
      glDrawPixels(DrawWidth, DrawHeight, ImgFormat, GL_UNSIGNED_BYTE, Image);
 
107
      draws++;
 
108
      endTime = glutGet(GLUT_ELAPSED_TIME);
 
109
   } while (endTime - startTime < 4000);   /* 4 seconds */
 
110
 
 
111
   /* GL clean-up */
 
112
   glDisable(GL_SCISSOR_TEST);
 
113
   glDisable(GL_FOG);
 
114
 
 
115
   /* Results */
 
116
   seconds = (double) (endTime - startTime) / 1000.0;
 
117
   pixelsPerSecond = draws * DrawWidth * DrawHeight / seconds;
 
118
   printf("Result:  %d draws in %f seconds = %f pixels/sec\n",
 
119
          draws, seconds, pixelsPerSecond);
 
120
}
 
121
 
 
122
 
 
123
static void Reshape( int width, int height )
 
124
{
 
125
   glViewport( 0, 0, width, height );
 
126
   glMatrixMode( GL_PROJECTION );
 
127
   glLoadIdentity();
 
128
   glOrtho( 0.0, width, 0.0, height, 0.0, 2.0 );
 
129
   glMatrixMode( GL_MODELVIEW );
 
130
   glLoadIdentity();
 
131
 
 
132
   glScissor(width/4, height/4, width/2, height/2);
 
133
}
 
134
 
 
135
 
 
136
static void Key( unsigned char key, int x, int y )
 
137
{
 
138
   (void) x;
 
139
   (void) y;
 
140
   switch (key) {
 
141
      case ' ':
 
142
         Reset();
 
143
         break;
 
144
      case 'd':
 
145
         Dither = !Dither;
 
146
         if (Dither)
 
147
            glEnable(GL_DITHER);
 
148
         else
 
149
            glDisable(GL_DITHER);
 
150
         break;
 
151
      case 'w':
 
152
         if (DrawWidth > 0)
 
153
            DrawWidth--;
 
154
         break;
 
155
      case 'W':
 
156
         DrawWidth++;
 
157
         break;
 
158
      case 'h':
 
159
         if (DrawHeight > 0)
 
160
            DrawHeight--;
 
161
         break;
 
162
      case 'H':
 
163
         DrawHeight++;
 
164
         break;
 
165
      case 'p':
 
166
         if (SkipPixels > 0)
 
167
             SkipPixels--;
 
168
         break;
 
169
      case 'P':
 
170
         SkipPixels++;
 
171
         break;
 
172
      case 'r':
 
173
         if (SkipRows > 0)
 
174
             SkipRows--;
 
175
         break;
 
176
      case 'R':
 
177
         SkipRows++;
 
178
         break;
 
179
      case 's':
 
180
         Scissor = !Scissor;
 
181
         break;
 
182
      case 'x':
 
183
         Xzoom -= 0.1;
 
184
         break;
 
185
      case 'X':
 
186
         Xzoom += 0.1;
 
187
         break;
 
188
      case 'y':
 
189
         Yzoom -= 0.1;
 
190
         break;
 
191
      case 'Y':
 
192
         Yzoom += 0.1;
 
193
         break;
 
194
      case 'z':
 
195
         Zpos -= 0.1;
 
196
         printf("RasterPos Z = %g\n", Zpos);
 
197
         break;
 
198
      case 'Z':
 
199
         Zpos += 0.1;
 
200
         printf("RasterPos Z = %g\n", Zpos);
 
201
         break;
 
202
      case 'b':
 
203
         Benchmark();
 
204
         break;
 
205
      case 'F':
 
206
         Fog = !Fog;
 
207
         printf("Fog %d\n", Fog);
 
208
         break;
 
209
      case 'f':
 
210
         DrawFront = !DrawFront;
 
211
         if (DrawFront)
 
212
            glDrawBuffer(GL_FRONT);
 
213
         else
 
214
            glDrawBuffer(GL_BACK);
 
215
         printf("glDrawBuffer(%s)\n", DrawFront ? "GL_FRONT" : "GL_BACK");
 
216
         break;
 
217
      case 27:
 
218
         exit(0);
 
219
         break;
 
220
   }
 
221
   glutPostRedisplay();
 
222
}
 
223
 
 
224
 
 
225
static void SpecialKey( int key, int x, int y )
 
226
{
 
227
   (void) x;
 
228
   (void) y;
 
229
   switch (key) {
 
230
      case GLUT_KEY_UP:
 
231
         Ypos += 1;
 
232
         break;
 
233
      case GLUT_KEY_DOWN:
 
234
         Ypos -= 1;
 
235
         break;
 
236
      case GLUT_KEY_LEFT:
 
237
         Xpos -= 1;
 
238
         break;
 
239
      case GLUT_KEY_RIGHT:
 
240
         Xpos += 1;
 
241
         break;
 
242
   }
 
243
   glutPostRedisplay();
 
244
}
 
245
 
 
246
 
 
247
static void Init( GLboolean ciMode, const char *filename )
 
248
{
 
249
   static const GLfloat fogColor[4] = {0, 1, 0, 0};
 
250
 
 
251
   printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION));
 
252
   printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
 
253
 
 
254
   Image = LoadRGBImage( filename, &ImgWidth, &ImgHeight, &ImgFormat );
 
255
   if (!Image) {
 
256
      printf("Couldn't read %s\n", filename);
 
257
      exit(0);
 
258
   }
 
259
 
 
260
   if (ciMode) {
 
261
      /* Convert RGB image to grayscale */
 
262
      GLubyte *indexImage = (GLubyte *) malloc( ImgWidth * ImgHeight );
 
263
      GLint i;
 
264
      for (i=0; i<ImgWidth*ImgHeight; i++) {
 
265
         int gray = Image[i*3] + Image[i*3+1] + Image[i*3+2];
 
266
         indexImage[i] = gray / 3;
 
267
      }
 
268
      free(Image);
 
269
      Image = indexImage;
 
270
      ImgFormat = GL_COLOR_INDEX;
 
271
 
 
272
      for (i=0;i<255;i++) {
 
273
         float g = i / 255.0;
 
274
         glutSetColor(i, g, g, g);
 
275
      }
 
276
   }
 
277
 
 
278
   printf("Loaded %d by %d image\n", ImgWidth, ImgHeight );
 
279
 
 
280
   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
281
   glPixelStorei(GL_UNPACK_ROW_LENGTH, ImgWidth);
 
282
 
 
283
   glFogi(GL_FOG_MODE, GL_LINEAR);
 
284
   glFogf(GL_FOG_START, 0);
 
285
   glFogf(GL_FOG_END, 2);
 
286
   glFogfv(GL_FOG_COLOR, fogColor);
 
287
 
 
288
   Reset();
 
289
}
 
290
 
 
291
 
 
292
static void Usage(void)
 
293
{
 
294
   printf("Keys:\n");
 
295
   printf("       SPACE  Reset Parameters\n");
 
296
   printf("     Up/Down  Move image up/down\n");
 
297
   printf("  Left/Right  Move image left/right\n");
 
298
   printf("           x  Decrease X-axis PixelZoom\n");
 
299
   printf("           X  Increase X-axis PixelZoom\n");
 
300
   printf("           y  Decrease Y-axis PixelZoom\n");
 
301
   printf("           Y  Increase Y-axis PixelZoom\n");
 
302
   printf("           w  Decrease glDrawPixels width*\n");
 
303
   printf("           W  Increase glDrawPixels width*\n");
 
304
   printf("           h  Decrease glDrawPixels height*\n");
 
305
   printf("           H  Increase glDrawPixels height*\n");
 
306
   printf("           p  Decrease GL_UNPACK_SKIP_PIXELS*\n");
 
307
   printf("           P  Increase GL_UNPACK_SKIP_PIXELS*\n");
 
308
   printf("           r  Decrease GL_UNPACK_SKIP_ROWS*\n");
 
309
   printf("           R  Increase GL_UNPACK_SKIP_ROWS*\n");
 
310
   printf("           s  Toggle GL_SCISSOR_TEST\n");
 
311
   printf("           F  Toggle GL_FOG\n");
 
312
   printf("           z  Decrease RasterPos Z\n");
 
313
   printf("           Z  Increase RasterPos Z\n");
 
314
   
 
315
   printf("           f  Toggle front/back buffer drawing\n");
 
316
   printf("           b  Benchmark test\n");
 
317
   printf("         ESC  Exit\n");
 
318
   printf("* Warning: no limits are imposed on these parameters so it's\n");
 
319
   printf("  possible to cause a segfault if you go too far.\n");
 
320
}
 
321
 
 
322
 
 
323
int main( int argc, char *argv[] )
 
324
{
 
325
   GLboolean ciMode = GL_FALSE;
 
326
   const char *filename = IMAGE_FILE;
 
327
   int i = 1;
 
328
 
 
329
   if (argc > i && strcmp(argv[i], "-ci")==0) {
 
330
      ciMode = GL_TRUE;
 
331
      i++;
 
332
   }
 
333
   if (argc > i) {
 
334
      filename = argv[i];
 
335
   }
 
336
 
 
337
   glutInit( &argc, argv );
 
338
   glutInitWindowPosition( 0, 0 );
 
339
   glutInitWindowSize( 500, 400 );
 
340
 
 
341
   if (ciMode)
 
342
      glutInitDisplayMode( GLUT_INDEX | GLUT_DOUBLE );
 
343
   else
 
344
      glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE);
 
345
 
 
346
   glutCreateWindow(argv[0]);
 
347
 
 
348
   Init(ciMode, filename);
 
349
   Usage();
 
350
 
 
351
   glutReshapeFunc( Reshape );
 
352
   glutKeyboardFunc( Key );
 
353
   glutSpecialFunc( SpecialKey );
 
354
   glutDisplayFunc( Display );
 
355
 
 
356
   glutMainLoop();
 
357
   return 0;
 
358
}