← Back to branch summary

~ubuntu-branches/ubuntu/natty/mesa/natty-proposed

« back to all changes in this revision

Viewing changes to progs/samples/eval.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Hooker, Robert Hooker, Christopher James Halse Rogers
  • Date: 2010-09-14 08:55:40 UTC
  • mfrom: (1.2.28 upstream)
  • Revision ID: james.westby@ubuntu.com-20100914085540-m4fpl0hdjlfd4jgz
Tags: 7.9~git20100909-0ubuntu1
https://launchpad.net/bugs/631413
https://launchpad.net/bugs/628930
https://launchpad.net/bugs/628727
https://launchpad.net/bugs/596292
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/630315
https://launchpad.net/bugs/613694
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/578619
https://launchpad.net/bugs/626943
https://launchpad.net/bugs/610541
https://launchpad.net/bugs/601052
[ Robert Hooker ]
* New upstream git snapshot up to commit 94118fe2d4b1e5 (LP: #631413)
* New features include ATI HD5xxx series support in r600, and a vastly
  improved glsl compiler.
* Remove pre-generated .pc's, use the ones generated at build time
  instead.
* Remove all references to mesa-utils now that its no longer shipped
  with the mesa source.
* Disable the experimental ARB_fragment_shader option by default on
  i915, it exposes incomplete functionality that breaks KDE compositing
  among other things. It can be enabled via driconf still. (LP: #628930).

[ Christopher James Halse Rogers ]
* debian/patches/04_osmesa_version.diff:
  - Refresh for new upstream
* Bugs fixed in this release:
  - Fixes severe rendering corruption in Unity on radeon (LP: #628727,
    LP: #596292, LP: #599741, LP: #630315, LP: #613694, LP: #599741).
  - Also fixes rendering in gnome-shell (LP: #578619).
  - Flickering in OpenGL apps on radeon (LP: #626943, LP: #610541).
  - Provides preliminary support for new intel chips (LP: #601052).
* debian/rules:
  - Update configure flags to match upstream reshuffling.
  - Explicitly remove gallium DRI drivers that we don't want to ship.
* Update debian/gbp.conf for this Maverick-specific packaging
* libegl1-mesa-dri-x11,kms: There are no longer separate kms or x11 drivers
  for EGL, libegl1-mesa-drivers now contains a single driver that provides
  both backends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
progs/samples/eval.c
1
 
/*
2
 
 * Copyright (c) 1991, 1992, 1993 Silicon Graphics, Inc.
3
 
 *
4
 
 * Permission to use, copy, modify, distribute, and sell this software and
5
 
 * its documentation for any purpose is hereby granted without fee, provided
6
 
 * that (i) the above copyright notices and this permission notice appear in
7
 
 * all copies of the software and related documentation, and (ii) the name of
8
 
 * Silicon Graphics may not be used in any advertising or
9
 
 * publicity relating to the software without the specific, prior written
10
 
 * permission of Silicon Graphics.
11
 
 *
12
 
 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF
13
 
 * ANY KIND,
14
 
 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
15
 
 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
16
 
 *
17
 
 * IN NO EVENT SHALL SILICON GRAPHICS BE LIABLE FOR
18
 
 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
19
 
 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
20
 
 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
21
 
 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
22
 
 * OF THIS SOFTWARE.
23
 
 */
24
 
 
25
 
#include <stdio.h>
26
 
#include <string.h>
27
 
#include <stdlib.h>
28
 
#include <math.h>
29
 
#include <GL/glut.h>
30
 
 
31
 
 
32
 
#define VORDER 10
33
 
#define CORDER 10
34
 
#define TORDER 3
35
 
 
36
 
#define VMAJOR_ORDER 2
37
 
#define VMINOR_ORDER 3
38
 
 
39
 
#define CMAJOR_ORDER 2
40
 
#define CMINOR_ORDER 2
41
 
 
42
 
#define TMAJOR_ORDER 2
43
 
#define TMINOR_ORDER 2
44
 
 
45
 
#define VDIM 4
46
 
#define CDIM 4
47
 
#define TDIM 2
48
 
 
49
 
#define ONE_D 1
50
 
#define TWO_D 2
51
 
 
52
 
#define EVAL 3
53
 
#define MESH 4
54
 
 
55
 
 
56
 
GLenum doubleBuffer;
57
 
 
58
 
float rotX = 0.0, rotY = 0.0, translateZ = -1.0;
59
 
 
60
 
GLenum arrayType = ONE_D;
61
 
GLenum colorType = GL_FALSE;
62
 
GLenum textureType = GL_FALSE;
63
 
GLenum polygonFilled = GL_FALSE;
64
 
GLenum lighting = GL_FALSE;
65
 
GLenum mapPoint = GL_FALSE;
66
 
GLenum mapType = EVAL;
67
 
 
68
 
double point1[10*4] = {
69
 
    -0.5, 0.0, 0.0, 1.0,
70
 
    -0.4, 0.5, 0.0, 1.0,
71
 
    -0.3,-0.5, 0.0, 1.0,
72
 
    -0.2, 0.5, 0.0, 1.0,
73
 
    -0.1,-0.5, 0.0, 1.0,
74
 
    0.0, 0.5, 0.0, 1.0,
75
 
    0.1,-0.5, 0.0, 1.0,
76
 
    0.2, 0.5, 0.0, 1.0,
77
 
    0.3,-0.5, 0.0, 1.0,
78
 
    0.4, 0.0, 0.0, 1.0,
79
 
};
80
 
double cpoint1[10*4] = {
81
 
    0.0, 0.0, 1.0, 1.0,
82
 
    0.3, 0.0, 0.7, 1.0,
83
 
    0.6, 0.0, 0.3, 1.0,
84
 
    1.0, 0.0, 0.0, 1.0,
85
 
    1.0, 0.3, 0.0, 1.0,
86
 
    1.0, 0.6, 0.0, 1.0,
87
 
    1.0, 1.0, 0.0, 1.0,
88
 
    1.0, 1.0, 0.5, 1.0,
89
 
    1.0, 1.0, 1.0, 1.0,
90
 
};
91
 
double tpoint1[11*4] = {
92
 
    0.0, 0.0, 0.0, 1.0,
93
 
    0.0, 0.1, 0.0, 1.0,
94
 
    0.0, 0.2, 0.0, 1.0,
95
 
    0.0, 0.3, 0.0, 1.0,
96
 
    0.0, 0.4, 0.0, 1.0,
97
 
    0.0, 0.5, 0.0, 1.0,
98
 
    0.0, 0.6, 0.0, 1.0,
99
 
    0.0, 0.7, 0.0, 1.0,
100
 
    0.0, 0.8, 0.0, 1.0,
101
 
    0.0, 0.9, 0.0, 1.0,
102
 
};
103
 
double point2[2*3*4] = {
104
 
    -0.5, -0.5,  0.5, 1.0, 
105
 
     0.0,  1.0,  0.5, 1.0, 
106
 
     0.5, -0.5,  0.5, 1.0,
107
 
    -0.5,  0.5, -0.5, 1.0, 
108
 
     0.0, -1.0, -0.5, 1.0, 
109
 
     0.5,  0.5, -0.5, 1.0,
110
 
};
111
 
double cpoint2[2*2*4] = {
112
 
    0.0, 0.0, 0.0, 1.0,
113
 
    0.0, 0.0, 1.0, 1.0,
114
 
    0.0, 1.0, 0.0, 1.0,
115
 
    1.0, 1.0, 1.0, 1.0,
116
 
};
117
 
double tpoint2[2*2*2] = {
118
 
    0.0, 0.0, 0.0, 1.0,
119
 
    1.0, 0.0, 1.0, 1.0, 
120
 
};
121
 
float textureImage[4*2*4] =  {
122
 
    1.0, 1.0, 1.0, 1.0,
123
 
    1.0, 0.0, 0.0, 1.0,
124
 
    1.0, 0.0, 0.0, 1.0,
125
 
    1.0, 1.0, 1.0, 1.0, 
126
 
    1.0, 1.0, 1.0, 1.0,
127
 
    1.0, 0.0, 0.0, 1.0,
128
 
    1.0, 0.0, 0.0, 1.0,
129
 
    1.0, 1.0, 1.0, 1.0, 
130
 
};
131
 
 
132
 
 
133
 
static void Init(void)
134
 
{
135
 
    static float ambient[] = {0.1, 0.1, 0.1, 1.0};
136
 
    static float diffuse[] = {1.0, 1.0, 1.0, 1.0};
137
 
    static float position[] = {0.0, 0.0, -150.0, 0.0};
138
 
    static float front_mat_diffuse[] = {1.0, 0.2, 1.0, 1.0};
139
 
    static float back_mat_diffuse[] = {1.0, 1.0, 0.2, 1.0};
140
 
    static float lmodel_ambient[] = {1.0, 1.0, 1.0, 1.0};
141
 
    static float lmodel_twoside[] = {GL_TRUE};
142
 
    static float decal[] = {GL_DECAL};
143
 
    static float repeat[] = {GL_REPEAT};
144
 
    static float nr[] = {GL_NEAREST};
145
 
 
146
 
    glFrontFace(GL_CCW);
147
 
 
148
 
    glEnable(GL_DEPTH_TEST);
149
 
 
150
 
    glMap1d(GL_MAP1_VERTEX_4, 0.0, 1.0, VDIM, VORDER, point1);
151
 
    glMap1d(GL_MAP1_COLOR_4, 0.0, 1.0, CDIM, CORDER, cpoint1);
152
 
 
153
 
    glMap2d(GL_MAP2_VERTEX_4, 0.0, 1.0, VMINOR_ORDER*VDIM, VMAJOR_ORDER, 0.0,
154
 
            1.0, VDIM, VMINOR_ORDER, point2);
155
 
    glMap2d(GL_MAP2_COLOR_4, 0.0, 1.0, CMINOR_ORDER*CDIM, CMAJOR_ORDER, 0.0,
156
 
            1.0, CDIM, CMINOR_ORDER, cpoint2);
157
 
    glMap2d(GL_MAP2_TEXTURE_COORD_2, 0.0, 1.0, TMINOR_ORDER*TDIM,
158
 
            TMAJOR_ORDER, 0.0, 1.0, TDIM, TMINOR_ORDER, tpoint2);
159
 
 
160
 
    glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
161
 
    glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
162
 
    glLightfv(GL_LIGHT0, GL_POSITION, position);
163
 
    
164
 
    glMaterialfv(GL_FRONT, GL_DIFFUSE, front_mat_diffuse);
165
 
    glMaterialfv(GL_BACK, GL_DIFFUSE, back_mat_diffuse);
166
 
 
167
 
    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
168
 
    glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
169
 
 
170
 
    glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, decal);
171
 
    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, repeat);
172
 
    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, repeat);
173
 
    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, nr);
174
 
    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, nr);
175
 
    glTexImage2D(GL_TEXTURE_2D, 0, 4, 2, 4, 0, GL_RGBA, GL_FLOAT,
176
 
                 (GLvoid *)textureImage);
177
 
}
178
 
 
179
 
static void DrawPoints1(void)
180
 
{
181
 
    GLint i;
182
 
 
183
 
    glColor3f(0.0, 1.0, 0.0);
184
 
    glPointSize(2);
185
 
    glBegin(GL_POINTS);
186
 
        for (i = 0; i < VORDER; i++) {
187
 
            glVertex4dv(&point1[i*4]);
188
 
        }
189
 
    glEnd();
190
 
}
191
 
 
192
 
static void DrawPoints2(void)
193
 
{
194
 
    GLint i, j;
195
 
 
196
 
    glColor3f(1.0, 0.0, 1.0);
197
 
    glPointSize(2);
198
 
    glBegin(GL_POINTS);
199
 
        for (i = 0; i < VMAJOR_ORDER; i++) {
200
 
            for (j = 0; j < VMINOR_ORDER; j++) {
201
 
                glVertex4dv(&point2[i*4*VMINOR_ORDER+j*4]);
202
 
            }
203
 
        }
204
 
    glEnd();
205
 
}
206
 
 
207
 
static void DrawMapEval1(float du)
208
 
{
209
 
    float u;
210
 
 
211
 
    glColor3f(1.0, 0.0, 0.0);
212
 
    glBegin(GL_LINE_STRIP);
213
 
        for (u = 0.0; u < 1.0; u += du) {
214
 
            glEvalCoord1d(u);
215
 
        }
216
 
        glEvalCoord1d(1.0);
217
 
    glEnd();
218
 
}
219
 
 
220
 
static void DrawMapEval2(float du, float dv)
221
 
{
222
 
    float u, v, tmp;
223
 
 
224
 
    glColor3f(1.0, 0.0, 0.0);
225
 
    for (v = 0.0; v < 1.0; v += dv) {
226
 
        glBegin(GL_QUAD_STRIP);
227
 
            for (u = 0.0; u <= 1.0; u += du) {
228
 
                glEvalCoord2d(u,v);
229
 
                tmp = (v + dv < 1.0) ? (v + dv) : 1.0;
230
 
                glEvalCoord2d(u, tmp);
231
 
            }
232
 
            glEvalCoord2d(1.0, v);
233
 
            glEvalCoord2d(1.0, v+dv);
234
 
        glEnd();
235
 
    }
236
 
}
237
 
 
238
 
static void RenderEval(void)
239
 
{
240
 
 
241
 
    if (colorType) {
242
 
        glEnable(GL_MAP1_COLOR_4);
243
 
        glEnable(GL_MAP2_COLOR_4);
244
 
    } else {
245
 
        glDisable(GL_MAP1_COLOR_4);
246
 
        glDisable(GL_MAP2_COLOR_4);
247
 
    }
248
 
 
249
 
    if (textureType) {
250
 
        glEnable(GL_TEXTURE_2D);
251
 
        glEnable(GL_MAP2_TEXTURE_COORD_2);
252
 
    } else {
253
 
        glDisable(GL_TEXTURE_2D);
254
 
        glDisable(GL_MAP2_TEXTURE_COORD_2);
255
 
    }
256
 
 
257
 
    if (polygonFilled) {
258
 
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
259
 
    } else {
260
 
        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
261
 
    }
262
 
 
263
 
    glShadeModel(GL_SMOOTH);
264
 
 
265
 
    switch (mapType) {
266
 
      case EVAL:
267
 
        switch (arrayType) {
268
 
          case ONE_D:
269
 
            glDisable(GL_MAP2_VERTEX_4);
270
 
            glEnable(GL_MAP1_VERTEX_4);
271
 
            DrawPoints1();
272
 
            DrawMapEval1(0.1/VORDER);
273
 
            break;
274
 
          case TWO_D:
275
 
            glDisable(GL_MAP1_VERTEX_4);
276
 
            glEnable(GL_MAP2_VERTEX_4);
277
 
            DrawPoints2();
278
 
            DrawMapEval2(0.1/VMAJOR_ORDER,0.1/VMINOR_ORDER);
279
 
            break;
280
 
          default:
281
 
            break;
282
 
        }
283
 
        break;
284
 
      case MESH:
285
 
        switch (arrayType) {
286
 
          case ONE_D:
287
 
            DrawPoints1();
288
 
            glDisable(GL_MAP2_VERTEX_4);
289
 
            glEnable (GL_MAP1_VERTEX_4);
290
 
            glColor3f(0.0, 0.0, 1.0);
291
 
            glMapGrid1d(40, 0.0, 1.0);
292
 
            if (mapPoint) {
293
 
                glPointSize(2);
294
 
                glEvalMesh1(GL_POINT, 0, 40);
295
 
            } else {
296
 
                glEvalMesh1(GL_LINE, 0, 40);
297
 
            }
298
 
            break;
299
 
          case TWO_D:
300
 
            DrawPoints2();
301
 
            glDisable(GL_MAP1_VERTEX_4);
302
 
            glEnable(GL_MAP2_VERTEX_4);
303
 
            glColor3f(0.0, 0.0, 1.0);
304
 
            glMapGrid2d(20, 0.0, 1.0, 20, 0.0, 1.0);
305
 
            if (mapPoint) {
306
 
                glPointSize(2);
307
 
                glEvalMesh2(GL_POINT, 0, 20, 0, 20);
308
 
            } else if (polygonFilled) {
309
 
                glEvalMesh2(GL_FILL, 0, 20, 0, 20);
310
 
            } else {
311
 
                glEvalMesh2(GL_LINE, 0, 20, 0, 20);
312
 
            }
313
 
            break;
314
 
          default:
315
 
            break;
316
 
        }
317
 
        break;
318
 
      default:
319
 
        break;
320
 
    }
321
 
}
322
 
 
323
 
static void Reshape(int width, int height)
324
 
{
325
 
 
326
 
    glViewport(0, 0, (GLint)width, (GLint)height);
327
 
 
328
 
    glMatrixMode(GL_PROJECTION);
329
 
    glLoadIdentity();
330
 
    glOrtho(-1.0, 1.0, -1.0, 1.0, -0.5, 10.0);
331
 
    glMatrixMode(GL_MODELVIEW);
332
 
}
333
 
 
334
 
static void Key2(int key, int x, int y)
335
 
{
336
 
    switch (key) {
337
 
      case GLUT_KEY_LEFT:
338
 
        rotY -= 30;
339
 
        break;
340
 
      case GLUT_KEY_RIGHT:
341
 
        rotY += 30;
342
 
        break;
343
 
      case GLUT_KEY_UP:
344
 
        rotX -= 30;
345
 
        break;
346
 
      case GLUT_KEY_DOWN:
347
 
        rotX += 30;
348
 
        break;
349
 
      default:
350
 
        return;
351
 
    }
352
 
 
353
 
    glutPostRedisplay();
354
 
}
355
 
 
356
 
static void Key(unsigned char key, int x, int y)
357
 
{
358
 
    switch (key) {
359
 
      case 27:
360
 
        exit(1);
361
 
      case '1':
362
 
        arrayType = ONE_D;
363
 
        break;
364
 
      case '2':
365
 
        arrayType = TWO_D;
366
 
        break;
367
 
      case 'e':
368
 
        mapType = EVAL;
369
 
        break;
370
 
      case 'm':
371
 
        mapType = MESH;
372
 
        break;
373
 
      case 'f':
374
 
        polygonFilled = !polygonFilled;
375
 
        break;
376
 
      case 'p':
377
 
        mapPoint = !mapPoint;
378
 
        break;
379
 
      case 'c':
380
 
        colorType = !colorType;
381
 
        break;
382
 
      case 't':
383
 
        textureType = !textureType;
384
 
        break;
385
 
      case 'l':
386
 
        lighting =! lighting;
387
 
        if (lighting) {
388
 
            glEnable(GL_LIGHTING);
389
 
            glEnable(GL_LIGHT0);
390
 
            glEnable(GL_AUTO_NORMAL);
391
 
        } else {
392
 
            glDisable(GL_LIGHTING);
393
 
            glDisable(GL_LIGHT0);
394
 
            glDisable(GL_AUTO_NORMAL);
395
 
        }
396
 
        break;
397
 
      default:
398
 
        return;
399
 
    }
400
 
 
401
 
    glutPostRedisplay();
402
 
}
403
 
 
404
 
static void Draw(void)
405
 
{
406
 
 
407
 
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
408
 
 
409
 
    glPushMatrix();
410
 
 
411
 
    glTranslatef(0.0, 0.0 , translateZ);
412
 
    glRotatef(rotX, 1, 0, 0);
413
 
    glRotatef(rotY, 0, 1, 0);
414
 
    RenderEval();
415
 
 
416
 
    glPopMatrix();
417
 
 
418
 
    glFlush();
419
 
 
420
 
    if (doubleBuffer) {
421
 
        glutSwapBuffers();
422
 
    }
423
 
}
424
 
 
425
 
static GLenum Args(int argc, char **argv)
426
 
{
427
 
    GLint i;
428
 
 
429
 
    doubleBuffer = GL_FALSE;
430
 
 
431
 
    for (i = 1; i < argc; i++) {
432
 
        if (strcmp(argv[i], "-sb") == 0) {
433
 
            doubleBuffer = GL_FALSE;
434
 
        } else if (strcmp(argv[i], "-db") == 0) {
435
 
            doubleBuffer = GL_TRUE;
436
 
        } else {
437
 
            printf("%s (Bad option).\n", argv[i]);
438
 
            return GL_FALSE;
439
 
        }
440
 
    }
441
 
    return GL_TRUE;
442
 
}
443
 
 
444
 
int main(int argc, char **argv)
445
 
{
446
 
    GLenum type;
447
 
 
448
 
    glutInit(&argc, argv);
449
 
 
450
 
    if (Args(argc, argv) == GL_FALSE) {
451
 
        exit(1);
452
 
    }
453
 
 
454
 
    glutInitWindowPosition(0, 0); glutInitWindowSize( 300, 300);
455
 
 
456
 
    type = GLUT_RGB | GLUT_DEPTH;
457
 
    type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE;
458
 
    glutInitDisplayMode(type);
459
 
 
460
 
    if (glutCreateWindow("Evaluator Test") == GL_FALSE) {
461
 
        exit(1);
462
 
    }
463
 
 
464
 
    Init();
465
 
 
466
 
    glutReshapeFunc(Reshape);
467
 
    glutKeyboardFunc(Key);
468
 
    glutSpecialFunc(Key2);
469
 
    glutDisplayFunc(Draw);
470
 
    glutMainLoop();
471
 
        return 0;
472
 
}