← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/gallium/drivers/softpipe/sp_prim_vbuf.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:
src/gallium/drivers/softpipe/sp_prim_vbuf.c
76
76
}
77
77
 
78
78
 
79
 
 
80
 
 
81
 
 
82
 
 
83
 
 
 
79
/** This tells the draw module about our desired vertex layout */
84
80
static const struct vertex_info *
85
81
sp_vbuf_get_vertex_info(struct vbuf_render *vbr)
86
82
{
108
104
   return cvbr->vertex_buffer != NULL;
109
105
}
110
106
 
 
107
 
111
108
static void
112
109
sp_vbuf_release_vertices(struct vbuf_render *vbr)
113
110
{
114
111
   /* keep the old allocation for next time */
115
112
}
116
113
 
 
114
 
117
115
static void *
118
116
sp_vbuf_map_vertices(struct vbuf_render *vbr)
119
117
{
121
119
   return cvbr->vertex_buffer;
122
120
}
123
121
 
 
122
 
124
123
static void 
125
124
sp_vbuf_unmap_vertices(struct vbuf_render *vbr, 
126
125
                       ushort min_index,
144
143
   cvbr->softpipe->reduced_prim = u_reduced_prim(prim);
145
144
   cvbr->prim = prim;
146
145
   return TRUE;
147
 
 
148
146
}
149
147
 
150
148
 
160
158
 * draw elements / indexed primitives
161
159
 */
162
160
static void
163
 
sp_vbuf_draw(struct vbuf_render *vbr, const ushort *indices, uint nr)
 
161
sp_vbuf_draw_elements(struct vbuf_render *vbr, const ushort *indices, uint nr)
164
162
{
165
163
   struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
166
164
   struct softpipe_context *softpipe = cvbr->softpipe;
167
165
   const unsigned stride = softpipe->vertex_info_vbuf.size * sizeof(float);
168
166
   const void *vertex_buffer = cvbr->vertex_buffer;
169
 
   struct setup_context *setup_ctx = cvbr->setup;
 
167
   struct setup_context *setup = cvbr->setup;
 
168
   const boolean flatshade_first = softpipe->rasterizer->flatshade_first;
170
169
   unsigned i;
171
170
 
172
171
   switch (cvbr->prim) {
173
172
   case PIPE_PRIM_POINTS:
174
173
      for (i = 0; i < nr; i++) {
175
 
         sp_setup_point( setup_ctx,
176
 
                      get_vert(vertex_buffer, indices[i-0], stride) );
 
174
         sp_setup_point( setup,
 
175
                         get_vert(vertex_buffer, indices[i-0], stride) );
177
176
      }
178
177
      break;
179
178
 
180
179
   case PIPE_PRIM_LINES:
181
180
      for (i = 1; i < nr; i += 2) {
182
 
         sp_setup_line( setup_ctx,
183
 
                     get_vert(vertex_buffer, indices[i-1], stride),
184
 
                     get_vert(vertex_buffer, indices[i-0], stride) );
 
181
         sp_setup_line( setup,
 
182
                        get_vert(vertex_buffer, indices[i-1], stride),
 
183
                        get_vert(vertex_buffer, indices[i-0], stride) );
185
184
      }
186
185
      break;
187
186
 
188
187
   case PIPE_PRIM_LINE_STRIP:
189
188
      for (i = 1; i < nr; i ++) {
190
 
         sp_setup_line( setup_ctx,
191
 
                     get_vert(vertex_buffer, indices[i-1], stride),
192
 
                     get_vert(vertex_buffer, indices[i-0], stride) );
 
189
         sp_setup_line( setup,
 
190
                        get_vert(vertex_buffer, indices[i-1], stride),
 
191
                        get_vert(vertex_buffer, indices[i-0], stride) );
193
192
      }
194
193
      break;
195
194
 
196
195
   case PIPE_PRIM_LINE_LOOP:
197
196
      for (i = 1; i < nr; i ++) {
198
 
         sp_setup_line( setup_ctx,
199
 
                     get_vert(vertex_buffer, indices[i-1], stride),
200
 
                     get_vert(vertex_buffer, indices[i-0], stride) );
 
197
         sp_setup_line( setup,
 
198
                        get_vert(vertex_buffer, indices[i-1], stride),
 
199
                        get_vert(vertex_buffer, indices[i-0], stride) );
201
200
      }
202
201
      if (nr) {
203
 
         sp_setup_line( setup_ctx,
204
 
                     get_vert(vertex_buffer, indices[nr-1], stride),
205
 
                     get_vert(vertex_buffer, indices[0], stride) );
 
202
         sp_setup_line( setup,
 
203
                        get_vert(vertex_buffer, indices[nr-1], stride),
 
204
                        get_vert(vertex_buffer, indices[0], stride) );
206
205
      }
207
206
      break;
208
207
 
209
208
   case PIPE_PRIM_TRIANGLES:
210
 
      if (softpipe->rasterizer->flatshade_first) {
211
 
         for (i = 2; i < nr; i += 3) {
212
 
            sp_setup_tri( setup_ctx,
213
 
                       get_vert(vertex_buffer, indices[i-1], stride),
214
 
                       get_vert(vertex_buffer, indices[i-0], stride),
215
 
                       get_vert(vertex_buffer, indices[i-2], stride) );
216
 
         }
217
 
      }
218
 
      else {
219
 
         for (i = 2; i < nr; i += 3) {
220
 
            sp_setup_tri( setup_ctx,
 
209
      for (i = 2; i < nr; i += 3) {
 
210
         sp_setup_tri( setup,
221
211
                       get_vert(vertex_buffer, indices[i-2], stride),
222
212
                       get_vert(vertex_buffer, indices[i-1], stride),
223
213
                       get_vert(vertex_buffer, indices[i-0], stride) );
224
 
         }
225
214
      }
226
215
      break;
227
216
 
228
217
   case PIPE_PRIM_TRIANGLE_STRIP:
229
 
      if (softpipe->rasterizer->flatshade_first) {
 
218
      if (flatshade_first) {
230
219
         for (i = 2; i < nr; i += 1) {
231
 
            sp_setup_tri( setup_ctx,
232
 
                       get_vert(vertex_buffer, indices[i+(i&1)-1], stride),
233
 
                       get_vert(vertex_buffer, indices[i-(i&1)], stride),
234
 
                       get_vert(vertex_buffer, indices[i-2], stride) );
 
220
            /* emit first triangle vertex as first triangle vertex */
 
221
            sp_setup_tri( setup,
 
222
                          get_vert(vertex_buffer, indices[i-2], stride),
 
223
                          get_vert(vertex_buffer, indices[i+(i&1)-1], stride),
 
224
                          get_vert(vertex_buffer, indices[i-(i&1)], stride) );
 
225
 
235
226
         }
236
227
      }
237
228
      else {
238
229
         for (i = 2; i < nr; i += 1) {
239
 
            sp_setup_tri( setup_ctx,
240
 
                       get_vert(vertex_buffer, indices[i+(i&1)-2], stride),
241
 
                       get_vert(vertex_buffer, indices[i-(i&1)-1], stride),
242
 
                       get_vert(vertex_buffer, indices[i-0], stride) );
 
230
            /* emit last triangle vertex as last triangle vertex */
 
231
            sp_setup_tri( setup,
 
232
                          get_vert(vertex_buffer, indices[i+(i&1)-2], stride),
 
233
                          get_vert(vertex_buffer, indices[i-(i&1)-1], stride),
 
234
                          get_vert(vertex_buffer, indices[i-0], stride) );
243
235
         }
244
236
      }
245
237
      break;
246
238
 
247
239
   case PIPE_PRIM_TRIANGLE_FAN:
248
 
      if (softpipe->rasterizer->flatshade_first) {
 
240
      if (flatshade_first) {
249
241
         for (i = 2; i < nr; i += 1) {
250
 
            sp_setup_tri( setup_ctx,
251
 
                       get_vert(vertex_buffer, indices[i-0], stride),
252
 
                       get_vert(vertex_buffer, indices[0], stride),
253
 
                       get_vert(vertex_buffer, indices[i-1], stride) );
 
242
            /* emit first non-spoke vertex as first vertex */
 
243
            sp_setup_tri( setup,
 
244
                          get_vert(vertex_buffer, indices[i-1], stride),
 
245
                          get_vert(vertex_buffer, indices[i-0], stride),
 
246
                          get_vert(vertex_buffer, indices[0], stride) );
254
247
         }
255
248
      }
256
249
      else {
257
250
         for (i = 2; i < nr; i += 1) {
258
 
            sp_setup_tri( setup_ctx,
259
 
                       get_vert(vertex_buffer, indices[0], stride),
260
 
                       get_vert(vertex_buffer, indices[i-1], stride),
261
 
                       get_vert(vertex_buffer, indices[i-0], stride) );
 
251
            /* emit last non-spoke vertex as last vertex */
 
252
            sp_setup_tri( setup,
 
253
                          get_vert(vertex_buffer, indices[0], stride),
 
254
                          get_vert(vertex_buffer, indices[i-1], stride),
 
255
                          get_vert(vertex_buffer, indices[i-0], stride) );
262
256
         }
263
257
      }
264
258
      break;
265
259
 
266
260
   case PIPE_PRIM_QUADS:
267
 
      if (softpipe->rasterizer->flatshade_first) {
 
261
      /* GL quads don't follow provoking vertex convention */
 
262
      if (flatshade_first) { 
 
263
         /* emit last quad vertex as first triangle vertex */
268
264
         for (i = 3; i < nr; i += 4) {
269
 
            sp_setup_tri( setup_ctx,
270
 
                       get_vert(vertex_buffer, indices[i-2], stride),
271
 
                       get_vert(vertex_buffer, indices[i-1], stride),
272
 
                       get_vert(vertex_buffer, indices[i-3], stride) );
273
 
            sp_setup_tri( setup_ctx,
274
 
                       get_vert(vertex_buffer, indices[i-1], stride),
275
 
                       get_vert(vertex_buffer, indices[i-0], stride),
276
 
                       get_vert(vertex_buffer, indices[i-3], stride) );
 
265
            sp_setup_tri( setup,
 
266
                          get_vert(vertex_buffer, indices[i-0], stride),
 
267
                          get_vert(vertex_buffer, indices[i-3], stride),
 
268
                          get_vert(vertex_buffer, indices[i-2], stride) );
 
269
 
 
270
            sp_setup_tri( setup,
 
271
                          get_vert(vertex_buffer, indices[i-0], stride),
 
272
                          get_vert(vertex_buffer, indices[i-2], stride),
 
273
                          get_vert(vertex_buffer, indices[i-1], stride) );
277
274
         }
278
275
      }
279
276
      else {
 
277
         /* emit last quad vertex as last triangle vertex */
280
278
         for (i = 3; i < nr; i += 4) {
281
 
            sp_setup_tri( setup_ctx,
282
 
                       get_vert(vertex_buffer, indices[i-3], stride),
283
 
                       get_vert(vertex_buffer, indices[i-2], stride),
284
 
                       get_vert(vertex_buffer, indices[i-0], stride) );
 
279
            sp_setup_tri( setup,
 
280
                          get_vert(vertex_buffer, indices[i-3], stride),
 
281
                          get_vert(vertex_buffer, indices[i-2], stride),
 
282
                          get_vert(vertex_buffer, indices[i-0], stride) );
285
283
 
286
 
            sp_setup_tri( setup_ctx,
287
 
                       get_vert(vertex_buffer, indices[i-2], stride),
288
 
                       get_vert(vertex_buffer, indices[i-1], stride),
289
 
                       get_vert(vertex_buffer, indices[i-0], stride) );
 
284
            sp_setup_tri( setup,
 
285
                          get_vert(vertex_buffer, indices[i-2], stride),
 
286
                          get_vert(vertex_buffer, indices[i-1], stride),
 
287
                          get_vert(vertex_buffer, indices[i-0], stride) );
290
288
         }
291
289
      }
292
290
      break;
293
291
 
294
292
   case PIPE_PRIM_QUAD_STRIP:
295
 
      if (softpipe->rasterizer->flatshade_first) {
 
293
      /* GL quad strips don't follow provoking vertex convention */
 
294
      if (flatshade_first) { 
 
295
         /* emit last quad vertex as first triangle vertex */
296
296
         for (i = 3; i < nr; i += 2) {
297
 
            sp_setup_tri( setup_ctx,
298
 
                       get_vert(vertex_buffer, indices[i-0], stride),
299
 
                       get_vert(vertex_buffer, indices[i-1], stride),
300
 
                       get_vert(vertex_buffer, indices[i-3], stride));
301
 
            sp_setup_tri( setup_ctx,
302
 
                       get_vert(vertex_buffer, indices[i-2], stride),
303
 
                       get_vert(vertex_buffer, indices[i-0], stride),
304
 
                       get_vert(vertex_buffer, indices[i-3], stride) );
 
297
            sp_setup_tri( setup,
 
298
                          get_vert(vertex_buffer, indices[i-0], stride),
 
299
                          get_vert(vertex_buffer, indices[i-3], stride),
 
300
                          get_vert(vertex_buffer, indices[i-2], stride) );
 
301
            sp_setup_tri( setup,
 
302
                          get_vert(vertex_buffer, indices[i-0], stride),
 
303
                          get_vert(vertex_buffer, indices[i-1], stride),
 
304
                          get_vert(vertex_buffer, indices[i-3], stride) );
305
305
         }
306
306
      }
307
307
      else {
 
308
         /* emit last quad vertex as last triangle vertex */
308
309
         for (i = 3; i < nr; i += 2) {
309
 
            sp_setup_tri( setup_ctx,
310
 
                       get_vert(vertex_buffer, indices[i-3], stride),
311
 
                       get_vert(vertex_buffer, indices[i-2], stride),
312
 
                       get_vert(vertex_buffer, indices[i-0], stride) );
313
 
            sp_setup_tri( setup_ctx,
314
 
                       get_vert(vertex_buffer, indices[i-1], stride),
315
 
                       get_vert(vertex_buffer, indices[i-3], stride),
316
 
                       get_vert(vertex_buffer, indices[i-0], stride) );
 
310
            sp_setup_tri( setup,
 
311
                          get_vert(vertex_buffer, indices[i-3], stride),
 
312
                          get_vert(vertex_buffer, indices[i-2], stride),
 
313
                          get_vert(vertex_buffer, indices[i-0], stride) );
 
314
            sp_setup_tri( setup,
 
315
                          get_vert(vertex_buffer, indices[i-1], stride),
 
316
                          get_vert(vertex_buffer, indices[i-3], stride),
 
317
                          get_vert(vertex_buffer, indices[i-0], stride) );
317
318
         }
318
319
      }
319
320
      break;
320
321
 
321
322
   case PIPE_PRIM_POLYGON:
322
323
      /* Almost same as tri fan but the _first_ vertex specifies the flat
323
 
       * shading color.  Note that the first polygon vertex is passed as
324
 
       * the last triangle vertex here.
325
 
       * flatshade_first state makes no difference.
 
324
       * shading color.
326
325
       */
327
 
      for (i = 2; i < nr; i += 1) {
328
 
         sp_setup_tri( setup_ctx,
329
 
                    get_vert(vertex_buffer, indices[i-0], stride),
330
 
                    get_vert(vertex_buffer, indices[i-1], stride),
331
 
                    get_vert(vertex_buffer, indices[0], stride) );
 
326
      if (flatshade_first) { 
 
327
         /* emit first polygon  vertex as first triangle vertex */
 
328
         for (i = 2; i < nr; i += 1) {
 
329
            sp_setup_tri( setup,
 
330
                          get_vert(vertex_buffer, indices[0], stride),
 
331
                          get_vert(vertex_buffer, indices[i-1], stride),
 
332
                          get_vert(vertex_buffer, indices[i-0], stride) );
 
333
         }
 
334
      }
 
335
      else {
 
336
         /* emit first polygon  vertex as last triangle vertex */
 
337
         for (i = 2; i < nr; i += 1) {
 
338
            sp_setup_tri( setup,
 
339
                          get_vert(vertex_buffer, indices[i-1], stride),
 
340
                          get_vert(vertex_buffer, indices[i-0], stride),
 
341
                          get_vert(vertex_buffer, indices[0], stride) );
 
342
         }
332
343
      }
333
344
      break;
334
345
 
347
358
{
348
359
   struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
349
360
   struct softpipe_context *softpipe = cvbr->softpipe;
350
 
   struct setup_context *setup_ctx = cvbr->setup;
 
361
   struct setup_context *setup = cvbr->setup;
351
362
   const unsigned stride = softpipe->vertex_info_vbuf.size * sizeof(float);
352
363
   const void *vertex_buffer =
353
364
      (void *) get_vert(cvbr->vertex_buffer, start, stride);
 
365
   const boolean flatshade_first = softpipe->rasterizer->flatshade_first;
354
366
   unsigned i;
355
367
 
356
368
   switch (cvbr->prim) {
357
369
   case PIPE_PRIM_POINTS:
358
370
      for (i = 0; i < nr; i++) {
359
 
         sp_setup_point( setup_ctx,
360
 
                      get_vert(vertex_buffer, i-0, stride) );
 
371
         sp_setup_point( setup,
 
372
                         get_vert(vertex_buffer, i-0, stride) );
361
373
      }
362
374
      break;
363
375
 
364
376
   case PIPE_PRIM_LINES:
365
377
      for (i = 1; i < nr; i += 2) {
366
 
         sp_setup_line( setup_ctx,
367
 
                     get_vert(vertex_buffer, i-1, stride),
368
 
                     get_vert(vertex_buffer, i-0, stride) );
 
378
         sp_setup_line( setup,
 
379
                        get_vert(vertex_buffer, i-1, stride),
 
380
                        get_vert(vertex_buffer, i-0, stride) );
369
381
      }
370
382
      break;
371
383
 
372
384
   case PIPE_PRIM_LINE_STRIP:
373
385
      for (i = 1; i < nr; i ++) {
374
 
         sp_setup_line( setup_ctx,
 
386
         sp_setup_line( setup,
375
387
                     get_vert(vertex_buffer, i-1, stride),
376
388
                     get_vert(vertex_buffer, i-0, stride) );
377
389
      }
379
391
 
380
392
   case PIPE_PRIM_LINE_LOOP:
381
393
      for (i = 1; i < nr; i ++) {
382
 
         sp_setup_line( setup_ctx,
383
 
                     get_vert(vertex_buffer, i-1, stride),
384
 
                     get_vert(vertex_buffer, i-0, stride) );
 
394
         sp_setup_line( setup,
 
395
                        get_vert(vertex_buffer, i-1, stride),
 
396
                        get_vert(vertex_buffer, i-0, stride) );
385
397
      }
386
398
      if (nr) {
387
 
         sp_setup_line( setup_ctx,
388
 
                     get_vert(vertex_buffer, nr-1, stride),
389
 
                     get_vert(vertex_buffer, 0, stride) );
 
399
         sp_setup_line( setup,
 
400
                        get_vert(vertex_buffer, nr-1, stride),
 
401
                        get_vert(vertex_buffer, 0, stride) );
390
402
      }
391
403
      break;
392
404
 
393
405
   case PIPE_PRIM_TRIANGLES:
394
 
      if (softpipe->rasterizer->flatshade_first) {
395
 
         for (i = 2; i < nr; i += 3) {
396
 
            sp_setup_tri( setup_ctx,
397
 
                       get_vert(vertex_buffer, i-1, stride),
398
 
                       get_vert(vertex_buffer, i-0, stride),
399
 
                       get_vert(vertex_buffer, i-2, stride) );
400
 
         }
401
 
      }
402
 
      else {
403
 
         for (i = 2; i < nr; i += 3) {
404
 
            sp_setup_tri( setup_ctx,
 
406
      for (i = 2; i < nr; i += 3) {
 
407
         sp_setup_tri( setup,
405
408
                       get_vert(vertex_buffer, i-2, stride),
406
409
                       get_vert(vertex_buffer, i-1, stride),
407
410
                       get_vert(vertex_buffer, i-0, stride) );
408
 
         }
409
411
      }
410
412
      break;
411
413
 
412
414
   case PIPE_PRIM_TRIANGLE_STRIP:
413
 
      if (softpipe->rasterizer->flatshade_first) {
 
415
      if (flatshade_first) {
414
416
         for (i = 2; i < nr; i++) {
415
 
            sp_setup_tri( setup_ctx,
416
 
                       get_vert(vertex_buffer, i+(i&1)-1, stride),
417
 
                       get_vert(vertex_buffer, i-(i&1), stride),
418
 
                       get_vert(vertex_buffer, i-2, stride) );
 
417
            /* emit first triangle vertex as first triangle vertex */
 
418
            sp_setup_tri( setup,
 
419
                          get_vert(vertex_buffer, i-2, stride),
 
420
                          get_vert(vertex_buffer, i+(i&1)-1, stride),
 
421
                          get_vert(vertex_buffer, i-(i&1), stride) );
419
422
         }
420
423
      }
421
424
      else {
422
425
         for (i = 2; i < nr; i++) {
423
 
            sp_setup_tri( setup_ctx,
424
 
                       get_vert(vertex_buffer, i+(i&1)-2, stride),
425
 
                       get_vert(vertex_buffer, i-(i&1)-1, stride),
426
 
                       get_vert(vertex_buffer, i-0, stride) );
 
426
            /* emit last triangle vertex as last triangle vertex */
 
427
            sp_setup_tri( setup,
 
428
                          get_vert(vertex_buffer, i+(i&1)-2, stride),
 
429
                          get_vert(vertex_buffer, i-(i&1)-1, stride),
 
430
                          get_vert(vertex_buffer, i-0, stride) );
427
431
         }
428
432
      }
429
433
      break;
430
434
 
431
435
   case PIPE_PRIM_TRIANGLE_FAN:
432
 
      if (softpipe->rasterizer->flatshade_first) {
 
436
      if (flatshade_first) {
433
437
         for (i = 2; i < nr; i += 1) {
434
 
            sp_setup_tri( setup_ctx,
435
 
                       get_vert(vertex_buffer, i-0, stride),
436
 
                       get_vert(vertex_buffer, 0, stride),
437
 
                       get_vert(vertex_buffer, i-1, stride) );
 
438
            /* emit first non-spoke vertex as first vertex */
 
439
            sp_setup_tri( setup,
 
440
                          get_vert(vertex_buffer, i-1, stride),
 
441
                          get_vert(vertex_buffer, i-0, stride),
 
442
                          get_vert(vertex_buffer, 0, stride)  );
438
443
         }
439
444
      }
440
445
      else {
441
446
         for (i = 2; i < nr; i += 1) {
442
 
            sp_setup_tri( setup_ctx,
443
 
                       get_vert(vertex_buffer, 0, stride),
444
 
                       get_vert(vertex_buffer, i-1, stride),
445
 
                       get_vert(vertex_buffer, i-0, stride) );
 
447
            /* emit last non-spoke vertex as last vertex */
 
448
            sp_setup_tri( setup,
 
449
                          get_vert(vertex_buffer, 0, stride),
 
450
                          get_vert(vertex_buffer, i-1, stride),
 
451
                          get_vert(vertex_buffer, i-0, stride) );
446
452
         }
447
453
      }
448
454
      break;
449
455
 
450
456
   case PIPE_PRIM_QUADS:
451
 
      if (softpipe->rasterizer->flatshade_first) {
 
457
      /* GL quads don't follow provoking vertex convention */
 
458
      if (flatshade_first) { 
 
459
         /* emit last quad vertex as first triangle vertex */
452
460
         for (i = 3; i < nr; i += 4) {
453
 
            sp_setup_tri( setup_ctx,
454
 
                       get_vert(vertex_buffer, i-2, stride),
455
 
                       get_vert(vertex_buffer, i-1, stride),
456
 
                       get_vert(vertex_buffer, i-3, stride) );
457
 
            sp_setup_tri( setup_ctx,
458
 
                       get_vert(vertex_buffer, i-1, stride),
459
 
                       get_vert(vertex_buffer, i-0, stride),
460
 
                       get_vert(vertex_buffer, i-3, stride) );
 
461
            sp_setup_tri( setup,
 
462
                          get_vert(vertex_buffer, i-0, stride),
 
463
                          get_vert(vertex_buffer, i-3, stride),
 
464
                          get_vert(vertex_buffer, i-2, stride) );
 
465
            sp_setup_tri( setup,
 
466
                          get_vert(vertex_buffer, i-0, stride),
 
467
                          get_vert(vertex_buffer, i-2, stride),
 
468
                          get_vert(vertex_buffer, i-1, stride) );
461
469
         }
462
470
      }
463
471
      else {
 
472
         /* emit last quad vertex as last triangle vertex */
464
473
         for (i = 3; i < nr; i += 4) {
465
 
            sp_setup_tri( setup_ctx,
466
 
                       get_vert(vertex_buffer, i-3, stride),
467
 
                       get_vert(vertex_buffer, i-2, stride),
468
 
                       get_vert(vertex_buffer, i-0, stride) );
469
 
            sp_setup_tri( setup_ctx,
470
 
                       get_vert(vertex_buffer, i-2, stride),
471
 
                       get_vert(vertex_buffer, i-1, stride),
472
 
                       get_vert(vertex_buffer, i-0, stride) );
 
474
            sp_setup_tri( setup,
 
475
                          get_vert(vertex_buffer, i-3, stride),
 
476
                          get_vert(vertex_buffer, i-2, stride),
 
477
                          get_vert(vertex_buffer, i-0, stride) );
 
478
            sp_setup_tri( setup,
 
479
                          get_vert(vertex_buffer, i-2, stride),
 
480
                          get_vert(vertex_buffer, i-1, stride),
 
481
                          get_vert(vertex_buffer, i-0, stride) );
473
482
         }
474
483
      }
475
484
      break;
476
485
 
477
486
   case PIPE_PRIM_QUAD_STRIP:
478
 
      if (softpipe->rasterizer->flatshade_first) {
 
487
      /* GL quad strips don't follow provoking vertex convention */
 
488
      if (flatshade_first) { 
 
489
         /* emit last quad vertex as first triangle vertex */
479
490
         for (i = 3; i < nr; i += 2) {
480
 
            sp_setup_tri( setup_ctx,
481
 
                       get_vert(vertex_buffer, i-0, stride),
482
 
                       get_vert(vertex_buffer, i-1, stride),
483
 
                       get_vert(vertex_buffer, i-3, stride) );
484
 
            sp_setup_tri( setup_ctx,
485
 
                       get_vert(vertex_buffer, i-2, stride),
486
 
                       get_vert(vertex_buffer, i-0, stride),
487
 
                       get_vert(vertex_buffer, i-3, stride) );
 
491
            sp_setup_tri( setup,
 
492
                          get_vert(vertex_buffer, i-0, stride),
 
493
                          get_vert(vertex_buffer, i-3, stride),
 
494
                          get_vert(vertex_buffer, i-2, stride) );
 
495
            sp_setup_tri( setup,
 
496
                          get_vert(vertex_buffer, i-0, stride),
 
497
                          get_vert(vertex_buffer, i-1, stride),
 
498
                          get_vert(vertex_buffer, i-3, stride) );
488
499
         }
489
500
      }
490
501
      else {
 
502
         /* emit last quad vertex as last triangle vertex */
491
503
         for (i = 3; i < nr; i += 2) {
492
 
            sp_setup_tri( setup_ctx,
493
 
                       get_vert(vertex_buffer, i-3, stride),
494
 
                       get_vert(vertex_buffer, i-2, stride),
495
 
                       get_vert(vertex_buffer, i-0, stride) );
496
 
            sp_setup_tri( setup_ctx,
497
 
                       get_vert(vertex_buffer, i-1, stride),
498
 
                       get_vert(vertex_buffer, i-3, stride),
499
 
                       get_vert(vertex_buffer, i-0, stride) );
 
504
            sp_setup_tri( setup,
 
505
                          get_vert(vertex_buffer, i-3, stride),
 
506
                          get_vert(vertex_buffer, i-2, stride),
 
507
                          get_vert(vertex_buffer, i-0, stride) );
 
508
            sp_setup_tri( setup,
 
509
                          get_vert(vertex_buffer, i-1, stride),
 
510
                          get_vert(vertex_buffer, i-3, stride),
 
511
                          get_vert(vertex_buffer, i-0, stride) );
500
512
         }
501
513
      }
502
514
      break;
503
515
 
504
516
   case PIPE_PRIM_POLYGON:
505
517
      /* Almost same as tri fan but the _first_ vertex specifies the flat
506
 
       * shading color.  Note that the first polygon vertex is passed as
507
 
       * the last triangle vertex here.
508
 
       * flatshade_first state makes no difference.
 
518
       * shading color.
509
519
       */
510
 
      for (i = 2; i < nr; i += 1) {
511
 
         sp_setup_tri( setup_ctx,
512
 
                    get_vert(vertex_buffer, i-1, stride),
513
 
                    get_vert(vertex_buffer, i-0, stride),
514
 
                    get_vert(vertex_buffer, 0, stride) );
 
520
      if (flatshade_first) { 
 
521
         /* emit first polygon  vertex as first triangle vertex */
 
522
         for (i = 2; i < nr; i += 1) {
 
523
            sp_setup_tri( setup,
 
524
                          get_vert(vertex_buffer, 0, stride),
 
525
                          get_vert(vertex_buffer, i-1, stride),
 
526
                          get_vert(vertex_buffer, i-0, stride) );
 
527
         }
 
528
      }
 
529
      else {
 
530
         /* emit first polygon  vertex as last triangle vertex */
 
531
         for (i = 2; i < nr; i += 1) {
 
532
            sp_setup_tri( setup,
 
533
                          get_vert(vertex_buffer, i-1, stride),
 
534
                          get_vert(vertex_buffer, i-0, stride),
 
535
                          get_vert(vertex_buffer, 0, stride) );
 
536
         }
515
537
      }
516
538
      break;
517
539
 
520
542
   }
521
543
}
522
544
 
 
545
static void
 
546
sp_vbuf_so_info(struct vbuf_render *vbr, uint primitives, uint vertices)
 
547
{
 
548
   struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 
549
   struct softpipe_context *softpipe = cvbr->softpipe;
 
550
   unsigned i;
 
551
 
 
552
   for (i = 0; i < softpipe->so_target.num_buffers; ++i) {
 
553
      softpipe->so_target.so_count[i] += vertices;
 
554
   }
 
555
 
 
556
   softpipe->so_stats.num_primitives_written = primitives;
 
557
   softpipe->so_stats.primitives_storage_needed =
 
558
      vertices * 4 /*sizeof(float|int32)*/ * 4 /*x,y,z,w*/;
 
559
}
523
560
 
524
561
 
525
562
static void
526
563
sp_vbuf_destroy(struct vbuf_render *vbr)
527
564
{
528
565
   struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
529
 
   if(cvbr->vertex_buffer)
 
566
   if (cvbr->vertex_buffer)
530
567
      align_free(cvbr->vertex_buffer);
531
568
   sp_setup_destroy_context(cvbr->setup);
532
569
   FREE(cvbr);
551
588
   cvbr->base.map_vertices = sp_vbuf_map_vertices;
552
589
   cvbr->base.unmap_vertices = sp_vbuf_unmap_vertices;
553
590
   cvbr->base.set_primitive = sp_vbuf_set_primitive;
554
 
   cvbr->base.draw = sp_vbuf_draw;
 
591
   cvbr->base.draw_elements = sp_vbuf_draw_elements;
555
592
   cvbr->base.draw_arrays = sp_vbuf_draw_arrays;
556
593
   cvbr->base.release_vertices = sp_vbuf_release_vertices;
 
594
   cvbr->base.set_stream_output_info = sp_vbuf_so_info;
557
595
   cvbr->base.destroy = sp_vbuf_destroy;
558
596
 
559
597
   cvbr->softpipe = sp;