projects / mesa.git / blob
? search:


24291da91e46e9318d1c5208cf88adf7b94f5f01
[mesa.git] / src / gallium / drivers / llvmpipe / lp_setup_vbuf.c
1 /**************************************************************************
2 *
3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28 /**
29 * Interface between 'draw' module's output and the llvmpipe rasterizer/setup
30 * code. When the 'draw' module has finished filling a vertex buffer, the
31 * draw_arrays() functions below will be called. Loop over the vertices and
32 * call the point/line/tri setup functions.
33 *
34 * Authors
35 * Brian Paul
36 */
37
38
39 #include "lp_setup_context.h"
40 #include "draw/draw_vbuf.h"
41 #include "draw/draw_vertex.h"
42 #include "util/u_memory.h"
43
44
45 #define LP_MAX_VBUF_INDEXES 1024
46 #define LP_MAX_VBUF_SIZE 4096
47
48
49
50 /** cast wrapper */
51 static struct setup_context *
52 setup_context(struct vbuf_render *vbr)
53 {
54 return (struct setup_context *) vbr;
55 }
56
57
58
59 static const struct vertex_info *
60 lp_setup_get_vertex_info(struct vbuf_render *vbr)
61 {
62 struct setup_context *setup = setup_context(vbr);
63 return setup->vertex_info;
64 }
65
66
67 static boolean
68 lp_setup_allocate_vertices(struct vbuf_render *vbr,
69 ushort vertex_size, ushort nr_vertices)
70 {
71 struct setup_context *setup = setup_context(vbr);
72 unsigned size = vertex_size * nr_vertices;
73
74 if (setup->vertex_buffer_size < size) {
75 align_free(setup->vertex_buffer);
76 setup->vertex_buffer = align_malloc(size, 16);
77 setup->vertex_buffer_size = size;
78 }
79
80 setup->vertex_size = vertex_size;
81 setup->nr_vertices = nr_vertices;
82
83 return setup->vertex_buffer != NULL;
84 }
85
86 static void
87 lp_setup_release_vertices(struct vbuf_render *vbr)
88 {
89 /* keep the old allocation for next time */
90 }
91
92 static void *
93 lp_setup_map_vertices(struct vbuf_render *vbr)
94 {
95 struct setup_context *setup = setup_context(vbr);
96 return setup->vertex_buffer;
97 }
98
99 static void
100 lp_setup_unmap_vertices(struct vbuf_render *vbr,
101 ushort min_index,
102 ushort max_index )
103 {
104 struct setup_context *setup = setup_context(vbr);
105 assert( setup->vertex_buffer_size >= (max_index+1) * setup->vertex_size );
106 /* do nothing */
107 }
108
109
110 static boolean
111 lp_setup_set_primitive(struct vbuf_render *vbr, unsigned prim)
112 {
113 setup_context(vbr)->prim = prim;
114 return TRUE;
115 }
116
117 typedef const float (*const_float4_ptr)[4];
118
119 static INLINE const_float4_ptr get_vert( const void *vertex_buffer,
120 int index,
121 int stride )
122 {
123 return (const_float4_ptr)((char *)vertex_buffer + index * stride);
124 }
125
126 /**
127 * draw elements / indexed primitives
128 */
129 static void
130 lp_setup_draw(struct vbuf_render *vbr, const ushort *indices, uint nr)
131 {
132 struct setup_context *setup = setup_context(vbr);
133 const unsigned stride = setup->vertex_info->size * sizeof(float);
134 const void *vertex_buffer = setup->vertex_buffer;
135 unsigned i;
136
137 lp_setup_update_state(setup);
138
139 switch (setup->prim) {
140 case PIPE_PRIM_POINTS:
141 for (i = 0; i < nr; i++) {
142 setup->point( setup,
143 get_vert(vertex_buffer, indices[i-0], stride) );
144 }
145 break;
146
147 case PIPE_PRIM_LINES:
148 for (i = 1; i < nr; i += 2) {
149 setup->line( setup,
150 get_vert(vertex_buffer, indices[i-1], stride),
151 get_vert(vertex_buffer, indices[i-0], stride) );
152 }
153 break;
154
155 case PIPE_PRIM_LINE_STRIP:
156 for (i = 1; i < nr; i ++) {
157 setup->line( setup,
158 get_vert(vertex_buffer, indices[i-1], stride),
159 get_vert(vertex_buffer, indices[i-0], stride) );
160 }
161 break;
162
163 case PIPE_PRIM_LINE_LOOP:
164 for (i = 1; i < nr; i ++) {
165 setup->line( setup,
166 get_vert(vertex_buffer, indices[i-1], stride),
167 get_vert(vertex_buffer, indices[i-0], stride) );
168 }
169 if (nr) {
170 setup->line( setup,
171 get_vert(vertex_buffer, indices[nr-1], stride),
172 get_vert(vertex_buffer, indices[0], stride) );
173 }
174 break;
175
176 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 }
192 }
193 break;
194
195 case PIPE_PRIM_TRIANGLE_STRIP:
196 if (setup->flatshade_first) {
197 for (i = 2; i < nr; i += 1) {
198 setup->triangle( setup,
199 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) );
202 }
203 }
204 else {
205 for (i = 2; i < nr; i += 1) {
206 setup->triangle( setup,
207 get_vert(vertex_buffer, indices[i+(i&1)-2], stride),
208 get_vert(vertex_buffer, indices[i-(i&1)-1], stride),
209 get_vert(vertex_buffer, indices[i-0], stride) );
210 }
211 }
212 break;
213
214 case PIPE_PRIM_TRIANGLE_FAN:
215 if (setup->flatshade_first) {
216 for (i = 2; i < nr; i += 1) {
217 setup->triangle( setup,
218 get_vert(vertex_buffer, indices[i-0], stride),
219 get_vert(vertex_buffer, indices[0], stride),
220 get_vert(vertex_buffer, indices[i-1], stride) );
221 }
222 }
223 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
253 setup->triangle( setup,
254 get_vert(vertex_buffer, indices[i-2], stride),
255 get_vert(vertex_buffer, indices[i-1], stride),
256 get_vert(vertex_buffer, indices[i-0], stride) );
257 }
258 }
259 break;
260
261 case PIPE_PRIM_QUAD_STRIP:
262 if (setup->flatshade_first) {
263 for (i = 3; i < nr; i += 2) {
264 setup->triangle( setup,
265 get_vert(vertex_buffer, indices[i-0], stride),
266 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 get_vert(vertex_buffer, indices[i-3], stride) );
272 }
273 }
274 else {
275 for (i = 3; i < nr; i += 2) {
276 setup->triangle( setup,
277 get_vert(vertex_buffer, indices[i-3], stride),
278 get_vert(vertex_buffer, indices[i-2], stride),
279 get_vert(vertex_buffer, indices[i-0], stride) );
280 setup->triangle( setup,
281 get_vert(vertex_buffer, indices[i-1], stride),
282 get_vert(vertex_buffer, indices[i-3], stride),
283 get_vert(vertex_buffer, indices[i-0], stride) );
284 }
285 }
286 break;
287
288 case PIPE_PRIM_POLYGON:
289 /* 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.
293 */
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) );
299 }
300 break;
301
302 default:
303 assert(0);
304 }
305 }
306
307
308 /**
309 * This function is hit when the draw module is working in pass-through mode.
310 * It's up to us to convert the vertex array into point/line/tri prims.
311 */
312 static void
313 lp_setup_draw_arrays(struct vbuf_render *vbr, uint start, uint nr)
314 {
315 struct setup_context *setup = setup_context(vbr);
316 const unsigned stride = setup->vertex_info->size * sizeof(float);
317 const void *vertex_buffer =
318 (void *) get_vert(setup->vertex_buffer, start, stride);
319 unsigned i;
320
321 lp_setup_update_state(setup);
322
323 switch (setup->prim) {
324 case PIPE_PRIM_POINTS:
325 for (i = 0; i < nr; i++) {
326 setup->point( setup,
327 get_vert(vertex_buffer, i-0, stride) );
328 }
329 break;
330
331 case PIPE_PRIM_LINES:
332 for (i = 1; i < nr; i += 2) {
333 setup->line( setup,
334 get_vert(vertex_buffer, i-1, stride),
335 get_vert(vertex_buffer, i-0, stride) );
336 }
337 break;
338
339 case PIPE_PRIM_LINE_STRIP:
340 for (i = 1; i < nr; i ++) {
341 setup->line( setup,
342 get_vert(vertex_buffer, i-1, stride),
343 get_vert(vertex_buffer, i-0, stride) );
344 }
345 break;
346
347 case PIPE_PRIM_LINE_LOOP:
348 for (i = 1; i < nr; i ++) {
349 setup->line( setup,
350 get_vert(vertex_buffer, i-1, stride),
351 get_vert(vertex_buffer, i-0, stride) );
352 }
353 if (nr) {
354 setup->line( setup,
355 get_vert(vertex_buffer, nr-1, stride),
356 get_vert(vertex_buffer, 0, stride) );
357 }
358 break;
359
360 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 }
376 }
377 break;
378
379 case PIPE_PRIM_TRIANGLE_STRIP:
380 if (setup->flatshade_first) {
381 for (i = 2; i < nr; i++) {
382 setup->triangle( setup,
383 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) );
386 }
387 }
388 else {
389 for (i = 2; i < nr; i++) {
390 setup->triangle( setup,
391 get_vert(vertex_buffer, i+(i&1)-2, stride),
392 get_vert(vertex_buffer, i-(i&1)-1, stride),
393 get_vert(vertex_buffer, i-0, stride) );
394 }
395 }
396 break;
397
398 case PIPE_PRIM_TRIANGLE_FAN:
399 if (setup->flatshade_first) {
400 for (i = 2; i < nr; i += 1) {
401 setup->triangle( setup,
402 get_vert(vertex_buffer, i-0, stride),
403 get_vert(vertex_buffer, 0, stride),
404 get_vert(vertex_buffer, i-1, stride) );
405 }
406 }
407 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 {
431 for (i = 3; i < nr; i += 4) {
432 setup->triangle( setup,
433 get_vert(vertex_buffer, i-3, stride),
434 get_vert(vertex_buffer, i-2, stride),
435 get_vert(vertex_buffer, i-0, stride) );
436 setup->triangle( setup,
437 get_vert(vertex_buffer, i-2, stride),
438 get_vert(vertex_buffer, i-1, stride),
439 get_vert(vertex_buffer, i-0, stride) );
440 }
441 }
442 break;
443
444 case PIPE_PRIM_QUAD_STRIP:
445 if (setup->flatshade_first) {
446 for (i = 3; i < nr; i += 2) {
447 setup->triangle( setup,
448 get_vert(vertex_buffer, i-0, stride),
449 get_vert(vertex_buffer, i-1, stride),
450 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 }
457 }
458 else {
459 for (i = 3; i < nr; i += 2) {
460 setup->triangle( setup,
461 get_vert(vertex_buffer, i-3, stride),
462 get_vert(vertex_buffer, i-2, stride),
463 get_vert(vertex_buffer, i-0, stride) );
464 setup->triangle( setup,
465 get_vert(vertex_buffer, i-1, stride),
466 get_vert(vertex_buffer, i-3, stride),
467 get_vert(vertex_buffer, i-0, stride) );
468 }
469 }
470 break;
471
472 case PIPE_PRIM_POLYGON:
473 /* 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.
477 */
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) );
483 }
484 break;
485
486 default:
487 assert(0);
488 }
489 }
490
491
492
493 static void
494 lp_setup_vbuf_destroy(struct vbuf_render *vbr)
495 {
496 lp_setup_destroy(setup_context(vbr));
497 }
498
499
500 /**
501 * Create the post-transform vertex handler for the given context.
502 */
503 void
504 lp_setup_init_vbuf(struct setup_context *setup)
505 {
506 setup->base.max_indices = LP_MAX_VBUF_INDEXES;
507 setup->base.max_vertex_buffer_bytes = LP_MAX_VBUF_SIZE;
508
509 setup->base.get_vertex_info = lp_setup_get_vertex_info;
510 setup->base.allocate_vertices = lp_setup_allocate_vertices;
511 setup->base.map_vertices = lp_setup_map_vertices;
512 setup->base.unmap_vertices = lp_setup_unmap_vertices;
513 setup->base.set_primitive = lp_setup_set_primitive;
514 setup->base.draw = lp_setup_draw;
515 setup->base.draw_arrays = lp_setup_draw_arrays;
516 setup->base.release_vertices = lp_setup_release_vertices;
517 setup->base.destroy = lp_setup_vbuf_destroy;
518 }