← Back to branch summary

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

« back to all changes in this revision

Viewing changes to progs/xdemos/corender.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/xdemos/corender.c
1
 
/**
2
 
 * Example of cooperative rendering into one window by two processes.
3
 
 * The first instance of the program creates the GLX window.
4
 
 * The second instance of the program gets the window ID from the first
5
 
 * and draws into it.
6
 
 * Socket IPC is used for synchronization.
7
 
 *
8
 
 * Usage:
9
 
 * 1. run 'corender &'
10
 
 * 2. run 'corender 2'  (any arg will do)
11
 
 *
12
 
 * Brian Paul
13
 
 * 11 Oct 2007
14
 
 */
15
 
 
16
 
 
17
 
#include <GL/gl.h>
18
 
#include <GL/glx.h>
19
 
#include <assert.h>
20
 
#include <math.h>
21
 
#include <stdio.h>
22
 
#include <stdlib.h>
23
 
#include <X11/keysym.h>
24
 
#include <unistd.h>
25
 
#include "ipc.h"
26
 
 
27
 
 
28
 
#ifndef M_PI
29
 
#define M_PI 3.14159265358979323846
30
 
#endif
31
 
 
32
 
static int MyID = 0;  /* 0 or 1 */
33
 
static int WindowID = 0;
34
 
static GLXContext Context = 0;
35
 
static int Width = 700, Height = 350;
36
 
static int Rot = 0;
37
 
static int Sock = 0;
38
 
 
39
 
static GLfloat Red[4] = {1.0, 0.2, 0.2, 1.0};
40
 
static GLfloat Blue[4] = {0.2, 0.2, 1.0, 1.0};
41
 
 
42
 
static int Sync = 1;  /** synchronized rendering? */
43
 
 
44
 
 
45
 
static void
46
 
setup_ipc(void)
47
 
{
48
 
   int k, port = 10001;
49
 
 
50
 
   if (MyID == 0) {
51
 
      /* I'm the first one, wait for connection from second */
52
 
      k = CreatePort(&port);
53
 
      assert(k != -1);
54
 
 
55
 
      printf("Waiting for connection from another 'corender'\n");
56
 
      Sock = AcceptConnection(k);
57
 
      assert(Sock != -1);
58
 
 
59
 
      printf("Got connection, sending windowID\n");
60
 
 
61
 
      /* send windowID */
62
 
      SendData(Sock, &WindowID, sizeof(WindowID));
63
 
   }
64
 
   else {
65
 
      /* I'm the second one, connect to first */
66
 
      char hostname[1000];
67
 
 
68
 
      MyHostName(hostname, 1000);
69
 
      Sock = Connect(hostname, port);
70
 
      assert(Sock != -1);
71
 
 
72
 
      /* get windowID */
73
 
      ReceiveData(Sock, &WindowID, sizeof(WindowID));
74
 
      printf("Contacted first 'corender', getting WindowID\n");
75
 
   }
76
 
}
77
 
 
78
 
 
79
 
 
80
 
/** from GLUT */
81
 
static void
82
 
doughnut(GLfloat r, GLfloat R, GLint nsides, GLint rings)
83
 
{
84
 
  int i, j;
85
 
  GLfloat theta, phi, theta1;
86
 
  GLfloat cosTheta, sinTheta;
87
 
  GLfloat cosTheta1, sinTheta1;
88
 
  GLfloat ringDelta, sideDelta;
89
 
 
90
 
  ringDelta = 2.0 * M_PI / rings;
91
 
  sideDelta = 2.0 * M_PI / nsides;
92
 
 
93
 
  theta = 0.0;
94
 
  cosTheta = 1.0;
95
 
  sinTheta = 0.0;
96
 
  for (i = rings - 1; i >= 0; i--) {
97
 
    theta1 = theta + ringDelta;
98
 
    cosTheta1 = cos(theta1);
99
 
    sinTheta1 = sin(theta1);
100
 
    glBegin(GL_QUAD_STRIP);
101
 
    phi = 0.0;
102
 
    for (j = nsides; j >= 0; j--) {
103
 
      GLfloat cosPhi, sinPhi, dist;
104
 
 
105
 
      phi += sideDelta;
106
 
      cosPhi = cos(phi);
107
 
      sinPhi = sin(phi);
108
 
      dist = R + r * cosPhi;
109
 
 
110
 
      glNormal3f(cosTheta1 * cosPhi, -sinTheta1 * cosPhi, sinPhi);
111
 
      glVertex3f(cosTheta1 * dist, -sinTheta1 * dist, r * sinPhi);
112
 
      glNormal3f(cosTheta * cosPhi, -sinTheta * cosPhi, sinPhi);
113
 
      glVertex3f(cosTheta * dist, -sinTheta * dist,  r * sinPhi);
114
 
    }
115
 
    glEnd();
116
 
    theta = theta1;
117
 
    cosTheta = cosTheta1;
118
 
    sinTheta = sinTheta1;
119
 
  }
120
 
}
121
 
 
122
 
 
123
 
static void
124
 
redraw(Display *dpy)
125
 
{
126
 
   int dbg = 0;
127
 
 
128
 
   glXMakeCurrent(dpy, WindowID, Context);
129
 
   glEnable(GL_LIGHTING);
130
 
   glEnable(GL_LIGHT0);
131
 
   glEnable(GL_DEPTH_TEST);
132
 
   glClearColor(0.5, 0.5, 0.5, 0.0);
133
 
 
134
 
   if (MyID == 0) {
135
 
      /* First process */
136
 
 
137
 
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
138
 
 
139
 
      glPushMatrix();
140
 
      glTranslatef(-1, 0, 0);
141
 
      glRotatef(Rot, 1, 0, 0);
142
 
      glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Red);
143
 
      doughnut(0.5, 2.0, 20, 30);
144
 
      glPopMatrix();
145
 
 
146
 
      glFinish();
147
 
      if (!Sync) {
148
 
         usleep(1000*10);
149
 
      }
150
 
 
151
 
      /* signal second process to render */
152
 
      if (Sync) {
153
 
         int code = 1;
154
 
         if (dbg) printf("0: send signal\n");
155
 
         SendData(Sock, &code, sizeof(code));
156
 
         SendData(Sock, &Rot, sizeof(Rot));
157
 
      }
158
 
 
159
 
      /* wait for second process to finish rendering */
160
 
      if (Sync) {
161
 
         int code = 0;
162
 
         if (dbg) printf("0: wait signal\n");
163
 
         ReceiveData(Sock, &code, sizeof(code));
164
 
         if (dbg) printf("0: got signal\n");
165
 
         assert(code == 2);
166
 
      }
167
 
 
168
 
   }
169
 
   else {
170
 
      /* Second process */
171
 
 
172
 
      /* wait for first process's signal for me to render */
173
 
      if (Sync) {
174
 
         int code = 0;
175
 
         if (dbg) printf("1: wait signal\n");
176
 
         ReceiveData(Sock, &code, sizeof(code));
177
 
         ReceiveData(Sock, &Rot, sizeof(Rot));
178
 
 
179
 
         if (dbg) printf("1: got signal\n");
180
 
         assert(code == 1);
181
 
      }
182
 
 
183
 
      /* XXX this clear should not be here, but for some reason, it
184
 
       * makes things _mostly_ work correctly w/ NVIDIA's driver.
185
 
       * There's only occasional glitches.
186
 
       * Without this glClear(), depth buffer for the second process
187
 
       * is pretty much broken.
188
 
       */
189
 
      /* glClear(GL_DEPTH_BUFFER_BIT); */
190
 
 
191
 
      glPushMatrix();
192
 
      glTranslatef(1, 0, 0);
193
 
      glRotatef(Rot + 90 , 1, 0, 0);
194
 
      glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Blue);
195
 
      doughnut(0.5, 2.0, 20, 30);
196
 
      glPopMatrix();
197
 
      glFinish();
198
 
 
199
 
      glXSwapBuffers(dpy, WindowID);
200
 
      usleep(1000*10);
201
 
 
202
 
      /* signal first process that I'm done rendering */
203
 
      if (Sync) {
204
 
         int code = 2;
205
 
         if (dbg) printf("1: send signal\n");
206
 
         SendData(Sock, &code, sizeof(code));
207
 
      }
208
 
   }
209
 
}
210
 
 
211
 
 
212
 
static void
213
 
resize(Display *dpy, int width, int height)
214
 
{
215
 
   float ar = (float) width / height;
216
 
 
217
 
   glXMakeCurrent(dpy, WindowID, Context);
218
 
 
219
 
   glViewport(0, 0, width, height);
220
 
   glMatrixMode(GL_PROJECTION);
221
 
   glLoadIdentity();
222
 
   glFrustum(-ar, ar, 1.0, -1.0, 5.0, 200.0);
223
 
   glMatrixMode(GL_MODELVIEW);
224
 
   glLoadIdentity();
225
 
   glTranslatef(0, 0, -15);
226
 
 
227
 
   Width = width;
228
 
   Height = height;
229
 
}
230
 
 
231
 
 
232
 
 
233
 
static void
234
 
set_window_title(Display *dpy, Window win, const char *title)
235
 
{
236
 
   XSizeHints sizehints;
237
 
   sizehints.flags = 0;
238
 
   XSetStandardProperties(dpy, win, title, title,
239
 
                          None, (char **)NULL, 0, &sizehints);
240
 
}
241
 
 
242
 
 
243
 
static Window
244
 
make_gl_window(Display *dpy, XVisualInfo *visinfo, int width, int height)
245
 
{
246
 
   int scrnum;
247
 
   XSetWindowAttributes attr;
248
 
   unsigned long mask;
249
 
   Window root;
250
 
   Window win;
251
 
   int x = 0, y = 0;
252
 
   char *name = NULL;
253
 
 
254
 
   scrnum = DefaultScreen( dpy );
255
 
   root = RootWindow( dpy, scrnum );
256
 
 
257
 
   /* window attributes */
258
 
   attr.background_pixel = 0;
259
 
   attr.border_pixel = 0;
260
 
   attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
261
 
   attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
262
 
   mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
263
 
 
264
 
   win = XCreateWindow( dpy, root, x, y, width, height,
265
 
                        0, visinfo->depth, InputOutput,
266
 
                        visinfo->visual, mask, &attr );
267
 
 
268
 
   /* set hints and properties */
269
 
   {
270
 
      XSizeHints sizehints;
271
 
      sizehints.x = x;
272
 
      sizehints.y = y;
273
 
      sizehints.width  = width;
274
 
      sizehints.height = height;
275
 
      sizehints.flags = USSize | USPosition;
276
 
      XSetNormalHints(dpy, win, &sizehints);
277
 
      XSetStandardProperties(dpy, win, name, name,
278
 
                              None, (char **)NULL, 0, &sizehints);
279
 
   }
280
 
 
281
 
   return win;
282
 
}
283
 
 
284
 
 
285
 
static void
286
 
set_event_mask(Display *dpy, Window win)
287
 
{
288
 
   XSetWindowAttributes attr;
289
 
   attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
290
 
   XChangeWindowAttributes(dpy, win, CWEventMask, &attr);
291
 
}
292
 
 
293
 
 
294
 
static void
295
 
event_loop(Display *dpy)
296
 
{
297
 
   while (1) {
298
 
      while (XPending(dpy) > 0) {
299
 
         XEvent event;
300
 
         XNextEvent(dpy, &event);
301
 
 
302
 
         switch (event.type) {
303
 
         case Expose:
304
 
            redraw(dpy);
305
 
            break;
306
 
         case ConfigureNotify:
307
 
            resize(dpy, event.xconfigure.width, event.xconfigure.height);
308
 
            break;
309
 
         case KeyPress:
310
 
            {
311
 
               char buffer[10];
312
 
               int r, code;
313
 
               code = XLookupKeysym(&event.xkey, 0);
314
 
               if (code == XK_Left) {
315
 
               }
316
 
               else {
317
 
                  r = XLookupString(&event.xkey, buffer, sizeof(buffer),
318
 
                                    NULL, NULL);
319
 
                  if (buffer[0] == 27) {
320
 
                     exit(0);
321
 
                  }
322
 
               }
323
 
            }
324
 
         default:
325
 
            /* nothing */
326
 
            ;
327
 
         }
328
 
      }
329
 
 
330
 
      if (MyID == 0 || !Sync)
331
 
         Rot += 1;
332
 
      redraw(dpy);
333
 
   }
334
 
}
335
 
 
336
 
 
337
 
static XVisualInfo *
338
 
choose_visual(Display *dpy)
339
 
{
340
 
   int attribs[] = { GLX_RGBA,
341
 
                     GLX_RED_SIZE, 1,
342
 
                     GLX_GREEN_SIZE, 1,
343
 
                     GLX_BLUE_SIZE, 1,
344
 
                     GLX_DOUBLEBUFFER,
345
 
                     GLX_DEPTH_SIZE, 1,
346
 
                     None };
347
 
   int scrnum = DefaultScreen( dpy );
348
 
   return glXChooseVisual(dpy, scrnum, attribs);
349
 
}
350
 
 
351
 
 
352
 
static void
353
 
parse_opts(int argc, char *argv[])
354
 
{
355
 
   if (argc > 1) {
356
 
      MyID = 1;
357
 
   }
358
 
}
359
 
 
360
 
 
361
 
int
362
 
main( int argc, char *argv[] )
363
 
{
364
 
   Display *dpy;
365
 
   XVisualInfo *visinfo;
366
 
 
367
 
   parse_opts(argc, argv);
368
 
 
369
 
   dpy = XOpenDisplay(NULL);
370
 
 
371
 
   visinfo = choose_visual(dpy);
372
 
 
373
 
   Context = glXCreateContext( dpy, visinfo, NULL, True );
374
 
   if (!Context) {
375
 
      printf("Error: glXCreateContext failed\n");
376
 
      exit(1);
377
 
   }
378
 
 
379
 
   if (MyID == 0) {
380
 
      WindowID = make_gl_window(dpy, visinfo, Width, Height);
381
 
      set_window_title(dpy, WindowID, "corender");
382
 
      XMapWindow(dpy, WindowID);
383
 
      /*printf("WindowID 0x%x\n", (int) WindowID);*/
384
 
   }
385
 
 
386
 
   /* do ipc hand-shake here */
387
 
   setup_ipc();
388
 
   assert(Sock);
389
 
   assert(WindowID);
390
 
 
391
 
   if (MyID == 1) {
392
 
      set_event_mask(dpy, WindowID);
393
 
   }
394
 
 
395
 
   resize(dpy, Width, Height);
396
 
 
397
 
   event_loop(dpy);
398
 
 
399
 
   return 0;
400
 
}