← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/gallium/drivers/llvmpipe/lp_setup_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/llvmpipe/lp_setup_vbuf.c
48
48
  
49
49
 
50
50
/** cast wrapper */
51
 
static struct setup_context *
52
 
setup_context(struct vbuf_render *vbr)
 
51
static struct lp_setup_context *
 
52
lp_setup_context(struct vbuf_render *vbr)
53
53
{
54
 
   return (struct setup_context *) vbr;
 
54
   return (struct lp_setup_context *) vbr;
55
55
}
56
56
 
57
57
 
59
59
static const struct vertex_info *
60
60
lp_setup_get_vertex_info(struct vbuf_render *vbr)
61
61
{
62
 
   struct setup_context *setup = setup_context(vbr);
 
62
   struct lp_setup_context *setup = lp_setup_context(vbr);
 
63
 
 
64
   /* Vertex size/info depends on the latest state.
 
65
    * The draw module may have issued additional state-change commands.
 
66
    */
 
67
   lp_setup_update_state(setup, FALSE);
 
68
 
63
69
   return setup->vertex_info;
64
70
}
65
71
 
68
74
lp_setup_allocate_vertices(struct vbuf_render *vbr,
69
75
                          ushort vertex_size, ushort nr_vertices)
70
76
{
71
 
   struct setup_context *setup = setup_context(vbr);
 
77
   struct lp_setup_context *setup = lp_setup_context(vbr);
72
78
   unsigned size = vertex_size * nr_vertices;
73
79
 
74
80
   if (setup->vertex_buffer_size < size) {
92
98
static void *
93
99
lp_setup_map_vertices(struct vbuf_render *vbr)
94
100
{
95
 
   struct setup_context *setup = setup_context(vbr);
 
101
   struct lp_setup_context *setup = lp_setup_context(vbr);
96
102
   return setup->vertex_buffer;
97
103
}
98
104
 
101
107
                       ushort min_index,
102
108
                       ushort max_index )
103
109
{
104
 
   struct setup_context *setup = setup_context(vbr);
 
110
   struct lp_setup_context *setup = lp_setup_context(vbr);
105
111
   assert( setup->vertex_buffer_size >= (max_index+1) * setup->vertex_size );
106
112
   /* do nothing */
107
113
}
110
116
static boolean
111
117
lp_setup_set_primitive(struct vbuf_render *vbr, unsigned prim)
112
118
{
113
 
   setup_context(vbr)->prim = prim;
 
119
   lp_setup_context(vbr)->prim = prim;
114
120
   return TRUE;
115
121
}
116
122
 
127
133
 * draw elements / indexed primitives
128
134
 */
129
135
static void
130
 
lp_setup_draw(struct vbuf_render *vbr, const ushort *indices, uint nr)
 
136
lp_setup_draw_elements(struct vbuf_render *vbr, const ushort *indices, uint nr)
131
137
{
132
 
   struct setup_context *setup = setup_context(vbr);
 
138
   struct lp_setup_context *setup = lp_setup_context(vbr);
133
139
   const unsigned stride = setup->vertex_info->size * sizeof(float);
134
140
   const void *vertex_buffer = setup->vertex_buffer;
 
141
   const boolean flatshade_first = setup->flatshade_first;
135
142
   unsigned i;
136
143
 
137
 
   lp_setup_update_state(setup);
 
144
   lp_setup_update_state(setup, TRUE);
138
145
 
139
146
   switch (setup->prim) {
140
147
   case PIPE_PRIM_POINTS:
174
181
      break;
175
182
 
176
183
   case PIPE_PRIM_TRIANGLES:
177
 
      if (setup->flatshade_first) {
178
 
         for (i = 2; i < nr; i += 3) {
179
 
            setup->triangle( setup,
180
 
                             get_vert(vertex_buffer, indices[i-1], stride),
181
 
                             get_vert(vertex_buffer, indices[i-0], stride),
182
 
                             get_vert(vertex_buffer, indices[i-2], stride) );
183
 
         }
184
 
      }
185
 
      else {
186
 
         for (i = 2; i < nr; i += 3) {
187
 
            setup->triangle( setup,
188
 
                             get_vert(vertex_buffer, indices[i-2], stride),
189
 
                             get_vert(vertex_buffer, indices[i-1], stride),
190
 
                             get_vert(vertex_buffer, indices[i-0], stride) );
191
 
         }
 
184
      for (i = 2; i < nr; i += 3) {
 
185
         setup->triangle( setup,
 
186
                          get_vert(vertex_buffer, indices[i-2], stride),
 
187
                          get_vert(vertex_buffer, indices[i-1], stride),
 
188
                          get_vert(vertex_buffer, indices[i-0], stride) );
192
189
      }
193
190
      break;
194
191
 
195
192
   case PIPE_PRIM_TRIANGLE_STRIP:
196
 
      if (setup->flatshade_first) {
 
193
      if (flatshade_first) {
197
194
         for (i = 2; i < nr; i += 1) {
 
195
            /* emit first triangle vertex as first triangle vertex */
198
196
            setup->triangle( setup,
 
197
                             get_vert(vertex_buffer, indices[i-2], stride),
199
198
                             get_vert(vertex_buffer, indices[i+(i&1)-1], stride),
200
 
                             get_vert(vertex_buffer, indices[i-(i&1)], stride),
201
 
                             get_vert(vertex_buffer, indices[i-2], stride) );
 
199
                             get_vert(vertex_buffer, indices[i-(i&1)], stride) );
 
200
 
202
201
         }
203
202
      }
204
203
      else {
205
204
         for (i = 2; i < nr; i += 1) {
 
205
            /* emit last triangle vertex as last triangle vertex */
206
206
            setup->triangle( setup,
207
207
                             get_vert(vertex_buffer, indices[i+(i&1)-2], stride),
208
208
                             get_vert(vertex_buffer, indices[i-(i&1)-1], stride),
212
212
      break;
213
213
 
214
214
   case PIPE_PRIM_TRIANGLE_FAN:
215
 
      if (setup->flatshade_first) {
 
215
      if (flatshade_first) {
216
216
         for (i = 2; i < nr; i += 1) {
 
217
            /* emit first non-spoke vertex as first vertex */
217
218
            setup->triangle( setup,
 
219
                             get_vert(vertex_buffer, indices[i-1], stride),
218
220
                             get_vert(vertex_buffer, indices[i-0], stride),
 
221
                             get_vert(vertex_buffer, indices[0], stride) );
 
222
         }
 
223
      }
 
224
      else {
 
225
         for (i = 2; i < nr; i += 1) {
 
226
            /* emit last non-spoke vertex as last vertex */
 
227
            setup->triangle( setup,
219
228
                             get_vert(vertex_buffer, indices[0], stride),
 
229
                             get_vert(vertex_buffer, indices[i-1], stride),
 
230
                             get_vert(vertex_buffer, indices[i-0], stride) );
 
231
         }
 
232
      }
 
233
      break;
 
234
 
 
235
   case PIPE_PRIM_QUADS:
 
236
      /* GL quads don't follow provoking vertex convention */
 
237
      if (flatshade_first) { 
 
238
         /* emit last quad vertex as first triangle vertex */
 
239
         for (i = 3; i < nr; i += 4) {
 
240
            setup->triangle( setup,
 
241
                             get_vert(vertex_buffer, indices[i-0], stride),
 
242
                             get_vert(vertex_buffer, indices[i-3], stride),
 
243
                             get_vert(vertex_buffer, indices[i-2], stride) );
 
244
 
 
245
            setup->triangle( setup,
 
246
                             get_vert(vertex_buffer, indices[i-0], stride),
 
247
                             get_vert(vertex_buffer, indices[i-2], stride),
220
248
                             get_vert(vertex_buffer, indices[i-1], stride) );
221
249
         }
222
250
      }
223
251
      else {
224
 
         for (i = 2; i < nr; i += 1) {
225
 
            setup->triangle( setup,
226
 
                             get_vert(vertex_buffer, indices[0], stride),
227
 
                             get_vert(vertex_buffer, indices[i-1], stride),
228
 
                             get_vert(vertex_buffer, indices[i-0], stride) );
229
 
         }
230
 
      }
231
 
      break;
232
 
 
233
 
   case PIPE_PRIM_QUADS:
234
 
      if (setup->flatshade_first) {
235
 
         for (i = 3; i < nr; i += 4) {
236
 
            setup->triangle( setup,
237
 
                             get_vert(vertex_buffer, indices[i-2], stride),
238
 
                             get_vert(vertex_buffer, indices[i-1], stride),
239
 
                             get_vert(vertex_buffer, indices[i-3], stride) );
240
 
            setup->triangle( setup,
241
 
                             get_vert(vertex_buffer, indices[i-1], stride),
242
 
                             get_vert(vertex_buffer, indices[i-0], stride),
243
 
                             get_vert(vertex_buffer, indices[i-3], stride) );
244
 
         }
245
 
      }
246
 
      else {
247
 
         for (i = 3; i < nr; i += 4) {
248
 
            setup->triangle( setup,
249
 
                             get_vert(vertex_buffer, indices[i-3], stride),
250
 
                             get_vert(vertex_buffer, indices[i-2], stride),
251
 
                             get_vert(vertex_buffer, indices[i-0], stride) );
 
252
         /* emit last quad vertex as last triangle vertex */
 
253
         for (i = 3; i < nr; i += 4) {
 
254
            setup->triangle( setup,
 
255
                          get_vert(vertex_buffer, indices[i-3], stride),
 
256
                          get_vert(vertex_buffer, indices[i-2], stride),
 
257
                          get_vert(vertex_buffer, indices[i-0], stride) );
252
258
 
253
259
            setup->triangle( setup,
254
260
                             get_vert(vertex_buffer, indices[i-2], stride),
259
265
      break;
260
266
 
261
267
   case PIPE_PRIM_QUAD_STRIP:
262
 
      if (setup->flatshade_first) {
 
268
      /* GL quad strips don't follow provoking vertex convention */
 
269
      if (flatshade_first) { 
 
270
         /* emit last quad vertex as first triangle vertex */
263
271
         for (i = 3; i < nr; i += 2) {
264
272
            setup->triangle( setup,
265
273
                             get_vert(vertex_buffer, indices[i-0], stride),
 
274
                             get_vert(vertex_buffer, indices[i-3], stride),
 
275
                             get_vert(vertex_buffer, indices[i-2], stride) );
 
276
            setup->triangle( setup,
 
277
                             get_vert(vertex_buffer, indices[i-0], stride),
266
278
                             get_vert(vertex_buffer, indices[i-1], stride),
267
 
                             get_vert(vertex_buffer, indices[i-3], stride));
268
 
            setup->triangle( setup,
269
 
                             get_vert(vertex_buffer, indices[i-2], stride),
270
 
                             get_vert(vertex_buffer, indices[i-0], stride),
271
279
                             get_vert(vertex_buffer, indices[i-3], stride) );
272
280
         }
273
281
      }
274
282
      else {
 
283
         /* emit last quad vertex as last triangle vertex */
275
284
         for (i = 3; i < nr; i += 2) {
276
285
            setup->triangle( setup,
277
286
                             get_vert(vertex_buffer, indices[i-3], stride),
287
296
 
288
297
   case PIPE_PRIM_POLYGON:
289
298
      /* Almost same as tri fan but the _first_ vertex specifies the flat
290
 
       * shading color.  Note that the first polygon vertex is passed as
291
 
       * the last triangle vertex here.
292
 
       * flatshade_first state makes no difference.
 
299
       * shading color.
293
300
       */
294
 
      for (i = 2; i < nr; i += 1) {
295
 
         setup->triangle( setup,
296
 
                          get_vert(vertex_buffer, indices[i-0], stride),
297
 
                          get_vert(vertex_buffer, indices[i-1], stride),
298
 
                          get_vert(vertex_buffer, indices[0], stride) );
 
301
      if (flatshade_first) { 
 
302
         /* emit first polygon  vertex as first triangle vertex */
 
303
         for (i = 2; i < nr; i += 1) {
 
304
            setup->triangle( setup,
 
305
                             get_vert(vertex_buffer, indices[0], stride),
 
306
                             get_vert(vertex_buffer, indices[i-1], stride),
 
307
                             get_vert(vertex_buffer, indices[i-0], stride) );
 
308
         }
 
309
      }
 
310
      else {
 
311
         /* emit first polygon  vertex as last triangle vertex */
 
312
         for (i = 2; i < nr; i += 1) {
 
313
            setup->triangle( setup,
 
314
                             get_vert(vertex_buffer, indices[i-1], stride),
 
315
                             get_vert(vertex_buffer, indices[i-0], stride),
 
316
                             get_vert(vertex_buffer, indices[0], stride) );
 
317
         }
299
318
      }
300
319
      break;
301
320
 
312
331
static void
313
332
lp_setup_draw_arrays(struct vbuf_render *vbr, uint start, uint nr)
314
333
{
315
 
   struct setup_context *setup = setup_context(vbr);
 
334
   struct lp_setup_context *setup = lp_setup_context(vbr);
316
335
   const unsigned stride = setup->vertex_info->size * sizeof(float);
317
336
   const void *vertex_buffer =
318
337
      (void *) get_vert(setup->vertex_buffer, start, stride);
 
338
   const boolean flatshade_first = setup->flatshade_first;
319
339
   unsigned i;
320
340
 
321
 
   lp_setup_update_state(setup);
 
341
   lp_setup_update_state(setup, TRUE);
322
342
 
323
343
   switch (setup->prim) {
324
344
   case PIPE_PRIM_POINTS:
358
378
      break;
359
379
 
360
380
   case PIPE_PRIM_TRIANGLES:
361
 
      if (setup->flatshade_first) {
362
 
         for (i = 2; i < nr; i += 3) {
363
 
            setup->triangle( setup,
364
 
                             get_vert(vertex_buffer, i-1, stride),
365
 
                             get_vert(vertex_buffer, i-0, stride),
366
 
                             get_vert(vertex_buffer, i-2, stride) );
367
 
         }
368
 
      }
369
 
      else {
370
 
         for (i = 2; i < nr; i += 3) {
371
 
            setup->triangle( setup,
372
 
                             get_vert(vertex_buffer, i-2, stride),
373
 
                             get_vert(vertex_buffer, i-1, stride),
374
 
                             get_vert(vertex_buffer, i-0, stride) );
375
 
         }
 
381
      for (i = 2; i < nr; i += 3) {
 
382
         setup->triangle( setup,
 
383
                          get_vert(vertex_buffer, i-2, stride),
 
384
                          get_vert(vertex_buffer, i-1, stride),
 
385
                          get_vert(vertex_buffer, i-0, stride) );
376
386
      }
377
387
      break;
378
388
 
379
389
   case PIPE_PRIM_TRIANGLE_STRIP:
380
 
      if (setup->flatshade_first) {
 
390
      if (flatshade_first) {
381
391
         for (i = 2; i < nr; i++) {
 
392
            /* emit first triangle vertex as first triangle vertex */
382
393
            setup->triangle( setup,
 
394
                             get_vert(vertex_buffer, i-2, stride),
383
395
                             get_vert(vertex_buffer, i+(i&1)-1, stride),
384
 
                             get_vert(vertex_buffer, i-(i&1), stride),
385
 
                             get_vert(vertex_buffer, i-2, stride) );
 
396
                             get_vert(vertex_buffer, i-(i&1), stride) );
386
397
         }
387
398
      }
388
399
      else {
389
400
         for (i = 2; i < nr; i++) {
 
401
            /* emit last triangle vertex as last triangle vertex */
390
402
            setup->triangle( setup,
391
403
                             get_vert(vertex_buffer, i+(i&1)-2, stride),
392
404
                             get_vert(vertex_buffer, i-(i&1)-1, stride),
396
408
      break;
397
409
 
398
410
   case PIPE_PRIM_TRIANGLE_FAN:
399
 
      if (setup->flatshade_first) {
 
411
      if (flatshade_first) {
400
412
         for (i = 2; i < nr; i += 1) {
 
413
            /* emit first non-spoke vertex as first vertex */
401
414
            setup->triangle( setup,
 
415
                             get_vert(vertex_buffer, i-1, stride),
402
416
                             get_vert(vertex_buffer, i-0, stride),
 
417
                             get_vert(vertex_buffer, 0, stride)  );
 
418
         }
 
419
      }
 
420
      else {
 
421
         for (i = 2; i < nr; i += 1) {
 
422
            /* emit last non-spoke vertex as last vertex */
 
423
            setup->triangle( setup,
403
424
                             get_vert(vertex_buffer, 0, stride),
 
425
                             get_vert(vertex_buffer, i-1, stride),
 
426
                             get_vert(vertex_buffer, i-0, stride) );
 
427
         }
 
428
      }
 
429
      break;
 
430
 
 
431
   case PIPE_PRIM_QUADS:
 
432
      /* GL quads don't follow provoking vertex convention */
 
433
      if (flatshade_first) { 
 
434
         /* emit last quad vertex as first triangle vertex */
 
435
         for (i = 3; i < nr; i += 4) {
 
436
            setup->triangle( setup,
 
437
                             get_vert(vertex_buffer, i-0, stride),
 
438
                             get_vert(vertex_buffer, i-3, stride),
 
439
                             get_vert(vertex_buffer, i-2, stride) );
 
440
            setup->triangle( setup,
 
441
                             get_vert(vertex_buffer, i-0, stride),
 
442
                             get_vert(vertex_buffer, i-2, stride),
404
443
                             get_vert(vertex_buffer, i-1, stride) );
405
444
         }
406
445
      }
407
446
      else {
408
 
         for (i = 2; i < nr; i += 1) {
409
 
            setup->triangle( setup,
410
 
                             get_vert(vertex_buffer, 0, stride),
411
 
                             get_vert(vertex_buffer, i-1, stride),
412
 
                             get_vert(vertex_buffer, i-0, stride) );
413
 
         }
414
 
      }
415
 
      break;
416
 
 
417
 
   case PIPE_PRIM_QUADS:
418
 
      if (setup->flatshade_first) {
419
 
         for (i = 3; i < nr; i += 4) {
420
 
            setup->triangle( setup,
421
 
                             get_vert(vertex_buffer, i-2, stride),
422
 
                             get_vert(vertex_buffer, i-1, stride),
423
 
                             get_vert(vertex_buffer, i-3, stride) );
424
 
            setup->triangle( setup,
425
 
                             get_vert(vertex_buffer, i-1, stride),
426
 
                             get_vert(vertex_buffer, i-0, stride),
427
 
                             get_vert(vertex_buffer, i-3, stride) );
428
 
         }
429
 
      }
430
 
      else {
 
447
         /* emit last quad vertex as last triangle vertex */
431
448
         for (i = 3; i < nr; i += 4) {
432
449
            setup->triangle( setup,
433
450
                             get_vert(vertex_buffer, i-3, stride),
442
459
      break;
443
460
 
444
461
   case PIPE_PRIM_QUAD_STRIP:
445
 
      if (setup->flatshade_first) {
 
462
      /* GL quad strips don't follow provoking vertex convention */
 
463
      if (flatshade_first) { 
 
464
         /* emit last quad vertex as first triangle vertex */
446
465
         for (i = 3; i < nr; i += 2) {
447
466
            setup->triangle( setup,
448
467
                             get_vert(vertex_buffer, i-0, stride),
 
468
                             get_vert(vertex_buffer, i-3, stride),
 
469
                             get_vert(vertex_buffer, i-2, stride) );
 
470
            setup->triangle( setup,
 
471
                             get_vert(vertex_buffer, i-0, stride),
449
472
                             get_vert(vertex_buffer, i-1, stride),
450
473
                             get_vert(vertex_buffer, i-3, stride) );
451
 
            setup->triangle( setup,
452
 
 
453
 
                             get_vert(vertex_buffer, i-2, stride),
454
 
                             get_vert(vertex_buffer, i-0, stride),
455
 
                             get_vert(vertex_buffer, i-3, stride) );
456
474
         }
457
475
      }
458
476
      else {
 
477
         /* emit last quad vertex as last triangle vertex */
459
478
         for (i = 3; i < nr; i += 2) {
460
479
            setup->triangle( setup,
461
480
                             get_vert(vertex_buffer, i-3, stride),
471
490
 
472
491
   case PIPE_PRIM_POLYGON:
473
492
      /* Almost same as tri fan but the _first_ vertex specifies the flat
474
 
       * shading color.  Note that the first polygon vertex is passed as
475
 
       * the last triangle vertex here.
476
 
       * flatshade_first state makes no difference.
 
493
       * shading color.
477
494
       */
478
 
      for (i = 2; i < nr; i += 1) {
479
 
         setup->triangle( setup,
480
 
                          get_vert(vertex_buffer, i-1, stride),
481
 
                          get_vert(vertex_buffer, i-0, stride),
482
 
                          get_vert(vertex_buffer, 0, stride) );
 
495
      if (flatshade_first) { 
 
496
         /* emit first polygon  vertex as first triangle vertex */
 
497
         for (i = 2; i < nr; i += 1) {
 
498
            setup->triangle( setup,
 
499
                             get_vert(vertex_buffer, 0, stride),
 
500
                             get_vert(vertex_buffer, i-1, stride),
 
501
                             get_vert(vertex_buffer, i-0, stride) );
 
502
         }
 
503
      }
 
504
      else {
 
505
         /* emit first polygon  vertex as last triangle vertex */
 
506
         for (i = 2; i < nr; i += 1) {
 
507
            setup->triangle( setup,
 
508
                             get_vert(vertex_buffer, i-1, stride),
 
509
                             get_vert(vertex_buffer, i-0, stride),
 
510
                             get_vert(vertex_buffer, 0, stride) );
 
511
         }
483
512
      }
484
513
      break;
485
514
 
493
522
static void
494
523
lp_setup_vbuf_destroy(struct vbuf_render *vbr)
495
524
{
496
 
   lp_setup_destroy(setup_context(vbr));
 
525
   struct lp_setup_context *setup = lp_setup_context(vbr);
 
526
   if (setup->vertex_buffer) {
 
527
      align_free(setup->vertex_buffer);
 
528
      setup->vertex_buffer = NULL;
 
529
   }
 
530
   lp_setup_destroy(setup);
497
531
}
498
532
 
499
533
 
501
535
 * Create the post-transform vertex handler for the given context.
502
536
 */
503
537
void
504
 
lp_setup_init_vbuf(struct setup_context *setup)
 
538
lp_setup_init_vbuf(struct lp_setup_context *setup)
505
539
{
506
540
   setup->base.max_indices = LP_MAX_VBUF_INDEXES;
507
541
   setup->base.max_vertex_buffer_bytes = LP_MAX_VBUF_SIZE;
511
545
   setup->base.map_vertices = lp_setup_map_vertices;
512
546
   setup->base.unmap_vertices = lp_setup_unmap_vertices;
513
547
   setup->base.set_primitive = lp_setup_set_primitive;
514
 
   setup->base.draw = lp_setup_draw;
 
548
   setup->base.draw_elements = lp_setup_draw_elements;
515
549
   setup->base.draw_arrays = lp_setup_draw_arrays;
516
550
   setup->base.release_vertices = lp_setup_release_vertices;
517
551
   setup->base.destroy = lp_setup_vbuf_destroy;