← Back to branch summary

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

« back to all changes in this revision

Viewing changes to progs/es2/xegl/tri.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/es2/xegl/tri.c
1
 
/**************************************************************************
2
 
 * 
3
 
 * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
4
 
 * All Rights Reserved.
5
 
 *
6
 
 **************************************************************************/
7
 
 
8
 
/*
9
 
 * Draw a triangle with X/EGL and OpenGL ES 2.x
10
 
 */
11
 
 
12
 
#define USE_FULL_GL 0
13
 
 
14
 
 
15
 
 
16
 
#include <assert.h>
17
 
#include <math.h>
18
 
#include <stdlib.h>
19
 
#include <stdio.h>
20
 
#include <string.h>
21
 
#include <X11/Xlib.h>
22
 
#include <X11/Xutil.h>
23
 
#include <X11/keysym.h>
24
 
#if USE_FULL_GL
25
 
#include <GL/gl.h>  /* use full OpenGL */
26
 
#else
27
 
#include <GLES2/gl2.h>  /* use OpenGL ES 2.x */
28
 
#endif
29
 
#include <EGL/egl.h>
30
 
 
31
 
 
32
 
#define FLOAT_TO_FIXED(X)   ((X) * 65535.0)
33
 
 
34
 
 
35
 
 
36
 
static GLfloat view_rotx = 0.0, view_roty = 0.0;
37
 
 
38
 
static GLint u_matrix = -1;
39
 
static GLint attr_pos = 0, attr_color = 1;
40
 
 
41
 
 
42
 
static void
43
 
make_z_rot_matrix(GLfloat angle, GLfloat *m)
44
 
{
45
 
   float c = cos(angle * M_PI / 180.0);
46
 
   float s = sin(angle * M_PI / 180.0);
47
 
   int i;
48
 
   for (i = 0; i < 16; i++)
49
 
      m[i] = 0.0;
50
 
   m[0] = m[5] = m[10] = m[15] = 1.0;
51
 
 
52
 
   m[0] = c;
53
 
   m[1] = s;
54
 
   m[4] = -s;
55
 
   m[5] = c;
56
 
}
57
 
 
58
 
static void
59
 
make_scale_matrix(GLfloat xs, GLfloat ys, GLfloat zs, GLfloat *m)
60
 
{
61
 
   int i;
62
 
   for (i = 0; i < 16; i++)
63
 
      m[i] = 0.0;
64
 
   m[0] = xs;
65
 
   m[5] = ys;
66
 
   m[10] = zs;
67
 
   m[15] = 1.0;
68
 
}
69
 
 
70
 
 
71
 
static void
72
 
mul_matrix(GLfloat *prod, const GLfloat *a, const GLfloat *b)
73
 
{
74
 
#define A(row,col)  a[(col<<2)+row]
75
 
#define B(row,col)  b[(col<<2)+row]
76
 
#define P(row,col)  p[(col<<2)+row]
77
 
   GLfloat p[16];
78
 
   GLint i;
79
 
   for (i = 0; i < 4; i++) {
80
 
      const GLfloat ai0=A(i,0),  ai1=A(i,1),  ai2=A(i,2),  ai3=A(i,3);
81
 
      P(i,0) = ai0 * B(0,0) + ai1 * B(1,0) + ai2 * B(2,0) + ai3 * B(3,0);
82
 
      P(i,1) = ai0 * B(0,1) + ai1 * B(1,1) + ai2 * B(2,1) + ai3 * B(3,1);
83
 
      P(i,2) = ai0 * B(0,2) + ai1 * B(1,2) + ai2 * B(2,2) + ai3 * B(3,2);
84
 
      P(i,3) = ai0 * B(0,3) + ai1 * B(1,3) + ai2 * B(2,3) + ai3 * B(3,3);
85
 
   }
86
 
   memcpy(prod, p, sizeof(p));
87
 
#undef A
88
 
#undef B
89
 
#undef PROD
90
 
}
91
 
 
92
 
 
93
 
static void
94
 
draw(void)
95
 
{
96
 
   static const GLfloat verts[3][2] = {
97
 
      { -1, -1 },
98
 
      {  1, -1 },
99
 
      {  0,  1 }
100
 
   };
101
 
   static const GLfloat colors[3][3] = {
102
 
      { 1, 0, 0 },
103
 
      { 0, 1, 0 },
104
 
      { 0, 0, 1 }
105
 
   };
106
 
   GLfloat mat[16], rot[16], scale[16];
107
 
 
108
 
   /* Set modelview/projection matrix */
109
 
   make_z_rot_matrix(view_rotx, rot);
110
 
   make_scale_matrix(0.5, 0.5, 0.5, scale);
111
 
   mul_matrix(mat, rot, scale);
112
 
   glUniformMatrix4fv(u_matrix, 1, GL_FALSE, mat);
113
 
 
114
 
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
115
 
 
116
 
   {
117
 
      glVertexAttribPointer(attr_pos, 2, GL_FLOAT, GL_FALSE, 0, verts);
118
 
      glVertexAttribPointer(attr_color, 3, GL_FLOAT, GL_FALSE, 0, colors);
119
 
      glEnableVertexAttribArray(attr_pos);
120
 
      glEnableVertexAttribArray(attr_color);
121
 
 
122
 
      glDrawArrays(GL_TRIANGLES, 0, 3);
123
 
 
124
 
      glDisableVertexAttribArray(attr_pos);
125
 
      glDisableVertexAttribArray(attr_color);
126
 
   }
127
 
}
128
 
 
129
 
 
130
 
/* new window size or exposure */
131
 
static void
132
 
reshape(int width, int height)
133
 
{
134
 
   glViewport(0, 0, (GLint) width, (GLint) height);
135
 
}
136
 
 
137
 
 
138
 
static void
139
 
create_shaders(void)
140
 
{
141
 
   static const char *fragShaderText =
142
 
      "varying vec4 v_color;\n"
143
 
      "void main() {\n"
144
 
      "   gl_FragColor = v_color;\n"
145
 
      "}\n";
146
 
   static const char *vertShaderText =
147
 
      "uniform mat4 modelviewProjection;\n"
148
 
      "attribute vec4 pos;\n"
149
 
      "attribute vec4 color;\n"
150
 
      "varying vec4 v_color;\n"
151
 
      "void main() {\n"
152
 
      "   gl_Position = modelviewProjection * pos;\n"
153
 
      "   v_color = color;\n"
154
 
      "}\n";
155
 
 
156
 
   GLuint fragShader, vertShader, program;
157
 
   GLint stat;
158
 
 
159
 
   fragShader = glCreateShader(GL_FRAGMENT_SHADER);
160
 
   glShaderSource(fragShader, 1, (const char **) &fragShaderText, NULL);
161
 
   glCompileShader(fragShader);
162
 
   glGetShaderiv(fragShader, GL_COMPILE_STATUS, &stat);
163
 
   if (!stat) {
164
 
      printf("Error: fragment shader did not compile!\n");
165
 
      exit(1);
166
 
   }
167
 
 
168
 
   vertShader = glCreateShader(GL_VERTEX_SHADER);
169
 
   glShaderSource(vertShader, 1, (const char **) &vertShaderText, NULL);
170
 
   glCompileShader(vertShader);
171
 
   glGetShaderiv(vertShader, GL_COMPILE_STATUS, &stat);
172
 
   if (!stat) {
173
 
      printf("Error: vertex shader did not compile!\n");
174
 
      exit(1);
175
 
   }
176
 
 
177
 
   program = glCreateProgram();
178
 
   glAttachShader(program, fragShader);
179
 
   glAttachShader(program, vertShader);
180
 
   glLinkProgram(program);
181
 
 
182
 
   glGetProgramiv(program, GL_LINK_STATUS, &stat);
183
 
   if (!stat) {
184
 
      char log[1000];
185
 
      GLsizei len;
186
 
      glGetProgramInfoLog(program, 1000, &len, log);
187
 
      printf("Error: linking:\n%s\n", log);
188
 
      exit(1);
189
 
   }
190
 
 
191
 
   glUseProgram(program);
192
 
 
193
 
   if (1) {
194
 
      /* test setting attrib locations */
195
 
      glBindAttribLocation(program, attr_pos, "pos");
196
 
      glBindAttribLocation(program, attr_color, "color");
197
 
      glLinkProgram(program);  /* needed to put attribs into effect */
198
 
   }
199
 
   else {
200
 
      /* test automatic attrib locations */
201
 
      attr_pos = glGetAttribLocation(program, "pos");
202
 
      attr_color = glGetAttribLocation(program, "color");
203
 
   }
204
 
 
205
 
   u_matrix = glGetUniformLocation(program, "modelviewProjection");
206
 
   printf("Uniform modelviewProjection at %d\n", u_matrix);
207
 
   printf("Attrib pos at %d\n", attr_pos);
208
 
   printf("Attrib color at %d\n", attr_color);
209
 
}
210
 
 
211
 
 
212
 
static void
213
 
init(void)
214
 
{
215
 
   typedef void (*proc)();
216
 
 
217
 
#if 1 /* test code */
218
 
   proc p = eglGetProcAddress("glMapBufferOES");
219
 
   assert(p);
220
 
#endif
221
 
 
222
 
   glClearColor(0.4, 0.4, 0.4, 0.0);
223
 
 
224
 
   create_shaders();
225
 
}
226
 
 
227
 
 
228
 
/*
229
 
 * Create an RGB, double-buffered X window.
230
 
 * Return the window and context handles.
231
 
 */
232
 
static void
233
 
make_x_window(Display *x_dpy, EGLDisplay egl_dpy,
234
 
              const char *name,
235
 
              int x, int y, int width, int height,
236
 
              Window *winRet,
237
 
              EGLContext *ctxRet,
238
 
              EGLSurface *surfRet)
239
 
{
240
 
   static const EGLint attribs[] = {
241
 
      EGL_RED_SIZE, 1,
242
 
      EGL_GREEN_SIZE, 1,
243
 
      EGL_BLUE_SIZE, 1,
244
 
      EGL_DEPTH_SIZE, 1,
245
 
      EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
246
 
      EGL_NONE
247
 
   };
248
 
   static const EGLint ctx_attribs[] = {
249
 
      EGL_CONTEXT_CLIENT_VERSION, 2,
250
 
      EGL_NONE
251
 
   };
252
 
   int scrnum;
253
 
   XSetWindowAttributes attr;
254
 
   unsigned long mask;
255
 
   Window root;
256
 
   Window win;
257
 
   XVisualInfo *visInfo, visTemplate;
258
 
   int num_visuals;
259
 
   EGLContext ctx;
260
 
   EGLConfig config;
261
 
   EGLint num_configs;
262
 
   EGLint vid;
263
 
 
264
 
   scrnum = DefaultScreen( x_dpy );
265
 
   root = RootWindow( x_dpy, scrnum );
266
 
 
267
 
   if (!eglChooseConfig( egl_dpy, attribs, &config, 1, &num_configs)) {
268
 
      printf("Error: couldn't get an EGL visual config\n");
269
 
      exit(1);
270
 
   }
271
 
 
272
 
   assert(config);
273
 
   assert(num_configs > 0);
274
 
 
275
 
   if (!eglGetConfigAttrib(egl_dpy, config, EGL_NATIVE_VISUAL_ID, &vid)) {
276
 
      printf("Error: eglGetConfigAttrib() failed\n");
277
 
      exit(1);
278
 
   }
279
 
 
280
 
   /* The X window visual must match the EGL config */
281
 
   visTemplate.visualid = vid;
282
 
   visInfo = XGetVisualInfo(x_dpy, VisualIDMask, &visTemplate, &num_visuals);
283
 
   if (!visInfo) {
284
 
      printf("Error: couldn't get X visual\n");
285
 
      exit(1);
286
 
   }
287
 
 
288
 
   /* window attributes */
289
 
   attr.background_pixel = 0;
290
 
   attr.border_pixel = 0;
291
 
   attr.colormap = XCreateColormap( x_dpy, root, visInfo->visual, AllocNone);
292
 
   attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
293
 
   mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
294
 
 
295
 
   win = XCreateWindow( x_dpy, root, 0, 0, width, height,
296
 
                        0, visInfo->depth, InputOutput,
297
 
                        visInfo->visual, mask, &attr );
298
 
 
299
 
   /* set hints and properties */
300
 
   {
301
 
      XSizeHints sizehints;
302
 
      sizehints.x = x;
303
 
      sizehints.y = y;
304
 
      sizehints.width  = width;
305
 
      sizehints.height = height;
306
 
      sizehints.flags = USSize | USPosition;
307
 
      XSetNormalHints(x_dpy, win, &sizehints);
308
 
      XSetStandardProperties(x_dpy, win, name, name,
309
 
                              None, (char **)NULL, 0, &sizehints);
310
 
   }
311
 
 
312
 
#if USE_FULL_GL /* XXX fix this when eglBindAPI() works */
313
 
   eglBindAPI(EGL_OPENGL_API);
314
 
#else
315
 
   eglBindAPI(EGL_OPENGL_ES_API);
316
 
#endif
317
 
 
318
 
   ctx = eglCreateContext(egl_dpy, config, EGL_NO_CONTEXT, ctx_attribs );
319
 
   if (!ctx) {
320
 
      printf("Error: eglCreateContext failed\n");
321
 
      exit(1);
322
 
   }
323
 
 
324
 
   /* test eglQueryContext() */
325
 
   {
326
 
      EGLint val;
327
 
      eglQueryContext(egl_dpy, ctx, EGL_CONTEXT_CLIENT_VERSION, &val);
328
 
      assert(val == 2);
329
 
   }
330
 
 
331
 
   *surfRet = eglCreateWindowSurface(egl_dpy, config, win, NULL);
332
 
   if (!*surfRet) {
333
 
      printf("Error: eglCreateWindowSurface failed\n");
334
 
      exit(1);
335
 
   }
336
 
 
337
 
   /* sanity checks */
338
 
   {
339
 
      EGLint val;
340
 
      eglQuerySurface(egl_dpy, *surfRet, EGL_WIDTH, &val);
341
 
      assert(val == width);
342
 
      eglQuerySurface(egl_dpy, *surfRet, EGL_HEIGHT, &val);
343
 
      assert(val == height);
344
 
      assert(eglGetConfigAttrib(egl_dpy, config, EGL_SURFACE_TYPE, &val));
345
 
      assert(val & EGL_WINDOW_BIT);
346
 
   }
347
 
 
348
 
   XFree(visInfo);
349
 
 
350
 
   *winRet = win;
351
 
   *ctxRet = ctx;
352
 
}
353
 
 
354
 
 
355
 
static void
356
 
event_loop(Display *dpy, Window win,
357
 
           EGLDisplay egl_dpy, EGLSurface egl_surf)
358
 
{
359
 
   while (1) {
360
 
      int redraw = 0;
361
 
      XEvent event;
362
 
 
363
 
      XNextEvent(dpy, &event);
364
 
 
365
 
      switch (event.type) {
366
 
      case Expose:
367
 
         redraw = 1;
368
 
         break;
369
 
      case ConfigureNotify:
370
 
         reshape(event.xconfigure.width, event.xconfigure.height);
371
 
         break;
372
 
      case KeyPress:
373
 
         {
374
 
            char buffer[10];
375
 
            int r, code;
376
 
            code = XLookupKeysym(&event.xkey, 0);
377
 
            if (code == XK_Left) {
378
 
               view_roty += 5.0;
379
 
            }
380
 
            else if (code == XK_Right) {
381
 
               view_roty -= 5.0;
382
 
            }
383
 
            else if (code == XK_Up) {
384
 
               view_rotx += 5.0;
385
 
            }
386
 
            else if (code == XK_Down) {
387
 
               view_rotx -= 5.0;
388
 
            }
389
 
            else {
390
 
               r = XLookupString(&event.xkey, buffer, sizeof(buffer),
391
 
                                 NULL, NULL);
392
 
               if (buffer[0] == 27) {
393
 
                  /* escape */
394
 
                  return;
395
 
               }
396
 
            }
397
 
         }
398
 
         redraw = 1;
399
 
         break;
400
 
      default:
401
 
         ; /*no-op*/
402
 
      }
403
 
 
404
 
      if (redraw) {
405
 
         draw();
406
 
         eglSwapBuffers(egl_dpy, egl_surf);
407
 
      }
408
 
   }
409
 
}
410
 
 
411
 
 
412
 
static void
413
 
usage(void)
414
 
{
415
 
   printf("Usage:\n");
416
 
   printf("  -display <displayname>  set the display to run on\n");
417
 
   printf("  -info                   display OpenGL renderer info\n");
418
 
}
419
 
 
420
 
 
421
 
int
422
 
main(int argc, char *argv[])
423
 
{
424
 
   const int winWidth = 300, winHeight = 300;
425
 
   Display *x_dpy;
426
 
   Window win;
427
 
   EGLSurface egl_surf;
428
 
   EGLContext egl_ctx;
429
 
   EGLDisplay egl_dpy;
430
 
   char *dpyName = NULL;
431
 
   GLboolean printInfo = GL_FALSE;
432
 
   EGLint egl_major, egl_minor;
433
 
   int i;
434
 
   const char *s;
435
 
 
436
 
   for (i = 1; i < argc; i++) {
437
 
      if (strcmp(argv[i], "-display") == 0) {
438
 
         dpyName = argv[i+1];
439
 
         i++;
440
 
      }
441
 
      else if (strcmp(argv[i], "-info") == 0) {
442
 
         printInfo = GL_TRUE;
443
 
      }
444
 
      else {
445
 
         usage();
446
 
         return -1;
447
 
      }
448
 
   }
449
 
 
450
 
   x_dpy = XOpenDisplay(dpyName);
451
 
   if (!x_dpy) {
452
 
      printf("Error: couldn't open display %s\n",
453
 
             dpyName ? dpyName : getenv("DISPLAY"));
454
 
      return -1;
455
 
   }
456
 
 
457
 
   egl_dpy = eglGetDisplay(x_dpy);
458
 
   if (!egl_dpy) {
459
 
      printf("Error: eglGetDisplay() failed\n");
460
 
      return -1;
461
 
   }
462
 
 
463
 
   if (!eglInitialize(egl_dpy, &egl_major, &egl_minor)) {
464
 
      printf("Error: eglInitialize() failed\n");
465
 
      return -1;
466
 
   }
467
 
 
468
 
   s = eglQueryString(egl_dpy, EGL_VERSION);
469
 
   printf("EGL_VERSION = %s\n", s);
470
 
 
471
 
   s = eglQueryString(egl_dpy, EGL_VENDOR);
472
 
   printf("EGL_VENDOR = %s\n", s);
473
 
 
474
 
   s = eglQueryString(egl_dpy, EGL_EXTENSIONS);
475
 
   printf("EGL_EXTENSIONS = %s\n", s);
476
 
 
477
 
   s = eglQueryString(egl_dpy, EGL_CLIENT_APIS);
478
 
   printf("EGL_CLIENT_APIS = %s\n", s);
479
 
 
480
 
   make_x_window(x_dpy, egl_dpy,
481
 
                 "OpenGL ES 2.x tri", 0, 0, winWidth, winHeight,
482
 
                 &win, &egl_ctx, &egl_surf);
483
 
 
484
 
   XMapWindow(x_dpy, win);
485
 
   if (!eglMakeCurrent(egl_dpy, egl_surf, egl_surf, egl_ctx)) {
486
 
      printf("Error: eglMakeCurrent() failed\n");
487
 
      return -1;
488
 
   }
489
 
 
490
 
   if (printInfo) {
491
 
      printf("GL_RENDERER   = %s\n", (char *) glGetString(GL_RENDERER));
492
 
      printf("GL_VERSION    = %s\n", (char *) glGetString(GL_VERSION));
493
 
      printf("GL_VENDOR     = %s\n", (char *) glGetString(GL_VENDOR));
494
 
      printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS));
495
 
   }
496
 
 
497
 
   init();
498
 
 
499
 
   /* Set initial projection/viewing transformation.
500
 
    * We can't be sure we'll get a ConfigureNotify event when the window
501
 
    * first appears.
502
 
    */
503
 
   reshape(winWidth, winHeight);
504
 
 
505
 
   event_loop(x_dpy, win, egl_dpy, egl_surf);
506
 
 
507
 
   eglDestroyContext(egl_dpy, egl_ctx);
508
 
   eglDestroySurface(egl_dpy, egl_surf);
509
 
   eglTerminate(egl_dpy);
510
 
 
511
 
 
512
 
   XDestroyWindow(x_dpy, win);
513
 
   XCloseDisplay(x_dpy);
514
 
 
515
 
   return 0;
516
 
}