projects / mesa.git / blob
? search:


c1bcd4b853147ebc715921ed0a484eb69def25d5
[mesa.git] / src / mesa / drivers / dri / mga / mgatris.c
1 /*
2 * Copyright 2000-2001 VA Linux Systems, Inc.
3 * All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * on the rights to use, copy, modify, merge, publish, distribute, sub
9 * license, and/or sell copies of the Software, and to permit persons to whom
10 * the Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
14 * Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
19 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * OTHER DEALINGS IN THE SOFTWARE.
23 *
24 * Authors:
25 * Keith Whitwell <keith@tungstengraphics.com>
26 */
27
28 #include "main/mtypes.h"
29 #include "main/macros.h"
30 #include "main/colormac.h"
31 #include "main/mm.h"
32 #include "swrast/swrast.h"
33 #include "swrast_setup/swrast_setup.h"
34 #include "tnl/t_context.h"
35 #include "tnl/t_pipeline.h"
36
37 #include "mgacontext.h"
38 #include "mgaioctl.h"
39 #include "mgatris.h"
40 #include "mgavb.h"
41 #include "mgastate.h"
42
43
44 static void mgaRenderPrimitive( GLcontext *ctx, GLenum prim );
45
46 /***********************************************************************
47 * Functions to draw basic primitives *
48 ***********************************************************************/
49
50
51 #if defined (USE_X86_ASM)
52 #define EMIT_VERT( j, vb, vertex_size, v ) \
53 do { int __tmp; \
54 __asm__ __volatile__( "rep ; movsl" \
55 : "=%c" (j), "=D" (vb), "=S" (__tmp) \
56 : "0" (vertex_size), \
57 "D" ((long)vb), \
58 "S" ((long)v)); \
59 } while (0)
60 #else
61 #define EMIT_VERT( j, vb, vertex_size, v ) \
62 do { \
63 for ( j = 0 ; j < vertex_size ; j++ ) \
64 vb[j] = (v)->ui[j]; \
65 vb += vertex_size; \
66 } while (0)
67 #endif
68
69 static void INLINE mga_draw_triangle( mgaContextPtr mmesa,
70 mgaVertexPtr v0,
71 mgaVertexPtr v1,
72 mgaVertexPtr v2 )
73 {
74 GLuint vertex_size = mmesa->vertex_size;
75 GLuint *vb = mgaAllocDmaLow( mmesa, 3 * 4 * vertex_size );
76 int j;
77
78 EMIT_VERT( j, vb, vertex_size, v0 );
79 EMIT_VERT( j, vb, vertex_size, v1 );
80 EMIT_VERT( j, vb, vertex_size, v2 );
81 }
82
83
84 static void INLINE mga_draw_quad( mgaContextPtr mmesa,
85 mgaVertexPtr v0,
86 mgaVertexPtr v1,
87 mgaVertexPtr v2,
88 mgaVertexPtr v3 )
89 {
90 GLuint vertex_size = mmesa->vertex_size;
91 GLuint *vb = mgaAllocDmaLow( mmesa, 6 * 4 * vertex_size );
92 int j;
93
94 EMIT_VERT( j, vb, vertex_size, v0 );
95 EMIT_VERT( j, vb, vertex_size, v1 );
96 EMIT_VERT( j, vb, vertex_size, v3 );
97 EMIT_VERT( j, vb, vertex_size, v1 );
98 EMIT_VERT( j, vb, vertex_size, v2 );
99 EMIT_VERT( j, vb, vertex_size, v3 );
100 }
101
102
103 static INLINE void mga_draw_point( mgaContextPtr mmesa,
104 mgaVertexPtr tmp )
105 {
106 const GLfloat sz = 0.5 * CLAMP(mmesa->glCtx->Point.Size,
107 mmesa->glCtx->Const.MinPointSize,
108 mmesa->glCtx->Const.MaxPointSize);
109 const int vertex_size = mmesa->vertex_size;
110 GLuint *vb = mgaAllocDmaLow( mmesa, 6 * 4 * vertex_size );
111 int j;
112
113 #if 0
114 v0->v.x += PNT_X_OFFSET - TRI_X_OFFSET;
115 v0->v.y += PNT_Y_OFFSET - TRI_Y_OFFSET;
116 #endif
117
118 /* Draw a point as two triangles.
119 */
120 *(float *)&vb[0] = tmp->v.x - sz;
121 *(float *)&vb[1] = tmp->v.y - sz;
122 for (j = 2 ; j < vertex_size ; j++)
123 vb[j] = tmp->ui[j];
124 vb += vertex_size;
125
126 *(float *)&vb[0] = tmp->v.x + sz;
127 *(float *)&vb[1] = tmp->v.y - sz;
128 for (j = 2 ; j < vertex_size ; j++)
129 vb[j] = tmp->ui[j];
130 vb += vertex_size;
131
132 *(float *)&vb[0] = tmp->v.x + sz;
133 *(float *)&vb[1] = tmp->v.y + sz;
134 for (j = 2 ; j < vertex_size ; j++)
135 vb[j] = tmp->ui[j];
136 vb += vertex_size;
137
138 *(float *)&vb[0] = tmp->v.x + sz;
139 *(float *)&vb[1] = tmp->v.y + sz;
140 for (j = 2 ; j < vertex_size ; j++)
141 vb[j] = tmp->ui[j];
142 vb += vertex_size;
143
144 *(float *)&vb[0] = tmp->v.x - sz;
145 *(float *)&vb[1] = tmp->v.y + sz;
146 for (j = 2 ; j < vertex_size ; j++)
147 vb[j] = tmp->ui[j];
148 vb += vertex_size;
149
150 *(float *)&vb[0] = tmp->v.x - sz;
151 *(float *)&vb[1] = tmp->v.y - sz;
152 for (j = 2 ; j < vertex_size ; j++)
153 vb[j] = tmp->ui[j];
154
155 #if 0
156 v0->v.x -= PNT_X_OFFSET - TRI_X_OFFSET;
157 v0->v.y -= PNT_Y_OFFSET - TRI_Y_OFFSET;
158 #endif
159 }
160
161
162 static INLINE void mga_draw_line( mgaContextPtr mmesa,
163 mgaVertexPtr v0,
164 mgaVertexPtr v1 )
165 {
166 GLuint vertex_size = mmesa->vertex_size;
167 GLuint *vb = mgaAllocDmaLow( mmesa, 6 * 4 * vertex_size );
168 GLfloat dx, dy, ix, iy;
169 const GLfloat width = CLAMP(mmesa->glCtx->Line.Width,
170 mmesa->glCtx->Const.MinLineWidth,
171 mmesa->glCtx->Const.MaxLineWidth);
172 GLint j;
173
174 #if 0
175 v0->v.x += LINE_X_OFFSET - TRI_X_OFFSET;
176 v0->v.y += LINE_Y_OFFSET - TRI_Y_OFFSET;
177 v1->v.x += LINE_X_OFFSET - TRI_X_OFFSET;
178 v1->v.y += LINE_Y_OFFSET - TRI_Y_OFFSET;
179 #endif
180
181 dx = v0->v.x - v1->v.x;
182 dy = v0->v.y - v1->v.y;
183
184 ix = width * .5; iy = 0;
185 if (dx * dx > dy * dy) {
186 iy = ix; ix = 0;
187 }
188
189 *(float *)&vb[0] = v0->v.x - ix;
190 *(float *)&vb[1] = v0->v.y - iy;
191 for (j = 2 ; j < vertex_size ; j++)
192 vb[j] = v0->ui[j];
193 vb += vertex_size;
194
195 *(float *)&vb[0] = v1->v.x + ix;
196 *(float *)&vb[1] = v1->v.y + iy;
197 for (j = 2 ; j < vertex_size ; j++)
198 vb[j] = v1->ui[j];
199 vb += vertex_size;
200
201 *(float *)&vb[0] = v0->v.x + ix;
202 *(float *)&vb[1] = v0->v.y + iy;
203 for (j = 2 ; j < vertex_size ; j++)
204 vb[j] = v0->ui[j];
205 vb += vertex_size;
206
207 *(float *)&vb[0] = v0->v.x - ix;
208 *(float *)&vb[1] = v0->v.y - iy;
209 for (j = 2 ; j < vertex_size ; j++)
210 vb[j] = v0->ui[j];
211 vb += vertex_size;
212
213 *(float *)&vb[0] = v1->v.x - ix;
214 *(float *)&vb[1] = v1->v.y - iy;
215 for (j = 2 ; j < vertex_size ; j++)
216 vb[j] = v1->ui[j];
217 vb += vertex_size;
218
219 *(float *)&vb[0] = v1->v.x + ix;
220 *(float *)&vb[1] = v1->v.y + iy;
221 for (j = 2 ; j < vertex_size ; j++)
222 vb[j] = v1->ui[j];
223 vb += vertex_size;
224
225 #if 0
226 v0->v.x -= LINE_X_OFFSET - TRI_X_OFFSET;
227 v0->v.y -= LINE_Y_OFFSET - TRI_Y_OFFSET;
228 v1->v.x -= LINE_X_OFFSET - TRI_X_OFFSET;
229 v1->v.y -= LINE_Y_OFFSET - TRI_Y_OFFSET;
230 #endif
231 }
232
233 /***********************************************************************
234 * Macros for t_dd_tritmp.h to draw basic primitives *
235 ***********************************************************************/
236
237 #define TRI( a, b, c ) \
238 do { \
239 if (DO_FALLBACK) \
240 mmesa->draw_tri( mmesa, a, b, c ); \
241 else \
242 mga_draw_triangle( mmesa, a, b, c ); \
243 } while (0)
244
245 #define QUAD( a, b, c, d ) \
246 do { \
247 if (DO_FALLBACK) { \
248 mmesa->draw_tri( mmesa, a, b, d ); \
249 mmesa->draw_tri( mmesa, b, c, d ); \
250 } else { \
251 mga_draw_quad( mmesa, a, b, c, d ); \
252 } \
253 } while (0)
254
255 #define LINE( v0, v1 ) \
256 do { \
257 if (DO_FALLBACK) \
258 mmesa->draw_line( mmesa, v0, v1 ); \
259 else { \
260 mga_draw_line( mmesa, v0, v1 ); \
261 } \
262 } while (0)
263
264 #define POINT( v0 ) \
265 do { \
266 if (DO_FALLBACK) \
267 mmesa->draw_point( mmesa, v0 ); \
268 else { \
269 mga_draw_point( mmesa, v0 ); \
270 } \
271 } while (0)
272
273
274 /***********************************************************************
275 * Fallback to swrast for basic primitives *
276 ***********************************************************************/
277
278 /* This code is hit only when a mix of accelerated and unaccelerated
279 * primitives are being drawn, and only for the unaccelerated
280 * primitives.
281 */
282
283 static void
284 mga_fallback_tri( mgaContextPtr mmesa,
285 mgaVertex *v0,
286 mgaVertex *v1,
287 mgaVertex *v2 )
288 {
289 GLcontext *ctx = mmesa->glCtx;
290 SWvertex v[3];
291 mga_translate_vertex( ctx, v0, &v[0] );
292 mga_translate_vertex( ctx, v1, &v[1] );
293 mga_translate_vertex( ctx, v2, &v[2] );
294 _swrast_Triangle( ctx, &v[0], &v[1], &v[2] );
295 }
296
297
298 static void
299 mga_fallback_line( mgaContextPtr mmesa,
300 mgaVertex *v0,
301 mgaVertex *v1 )
302 {
303 GLcontext *ctx = mmesa->glCtx;
304 SWvertex v[2];
305 mga_translate_vertex( ctx, v0, &v[0] );
306 mga_translate_vertex( ctx, v1, &v[1] );
307 _swrast_Line( ctx, &v[0], &v[1] );
308 }
309
310
311 static void
312 mga_fallback_point( mgaContextPtr mmesa,
313 mgaVertex *v0 )
314 {
315 GLcontext *ctx = mmesa->glCtx;
316 SWvertex v[1];
317 mga_translate_vertex( ctx, v0, &v[0] );
318 _swrast_Point( ctx, &v[0] );
319 }
320
321 /***********************************************************************
322 * Build render functions from dd templates *
323 ***********************************************************************/
324
325
326 #define MGA_UNFILLED_BIT 0x1
327 #define MGA_OFFSET_BIT 0x2
328 #define MGA_TWOSIDE_BIT 0x4
329 #define MGA_FLAT_BIT 0x8 /* mga can't flatshade? */
330 #define MGA_FALLBACK_BIT 0x10
331 #define MGA_MAX_TRIFUNC 0x20
332
333 static struct {
334 tnl_points_func points;
335 tnl_line_func line;
336 tnl_triangle_func triangle;
337 tnl_quad_func quad;
338 } rast_tab[MGA_MAX_TRIFUNC];
339
340 #define DO_FALLBACK (IND & MGA_FALLBACK_BIT)
341 #define DO_OFFSET (IND & MGA_OFFSET_BIT)
342 #define DO_UNFILLED (IND & MGA_UNFILLED_BIT)
343 #define DO_TWOSIDE (IND & MGA_TWOSIDE_BIT)
344 #define DO_FLAT (IND & MGA_FLAT_BIT)
345 #define DO_TRI 1
346 #define DO_QUAD 1
347 #define DO_LINE 1
348 #define DO_POINTS 1
349 #define DO_FULL_QUAD 1
350
351 #define HAVE_RGBA 1
352 #define HAVE_BACK_COLORS 0
353 #define HAVE_SPEC 1
354 #define HAVE_HW_FLATSHADE 0
355 #define VERTEX mgaVertex
356 #define TAB rast_tab
357
358
359 #define DEPTH_SCALE mmesa->depth_scale
360 #define UNFILLED_TRI unfilled_tri
361 #define UNFILLED_QUAD unfilled_quad
362 #define VERT_X(_v) _v->v.x
363 #define VERT_Y(_v) _v->v.y
364 #define VERT_Z(_v) _v->v.z
365 #define AREA_IS_CCW( a ) (a > 0)
366 #define GET_VERTEX(e) (mmesa->verts + (e * mmesa->vertex_size * sizeof(int)))
367
368 #define VERT_SET_RGBA( v, c ) \
369 do { \
370 mga_color_t *color = (mga_color_t *)&((v)->ui[4]); \
371 UNCLAMPED_FLOAT_TO_UBYTE(color->red, (c)[0]); \
372 UNCLAMPED_FLOAT_TO_UBYTE(color->green, (c)[1]); \
373 UNCLAMPED_FLOAT_TO_UBYTE(color->blue, (c)[2]); \
374 UNCLAMPED_FLOAT_TO_UBYTE(color->alpha, (c)[3]); \
375 } while (0)
376
377 #define VERT_COPY_RGBA( v0, v1 ) v0->ui[4] = v1->ui[4]
378
379 #define VERT_SET_SPEC( v0, c ) \
380 do { \
381 UNCLAMPED_FLOAT_TO_UBYTE(v0->v.specular.red, (c)[0]); \
382 UNCLAMPED_FLOAT_TO_UBYTE(v0->v.specular.green, (c)[1]); \
383 UNCLAMPED_FLOAT_TO_UBYTE(v0->v.specular.blue, (c)[2]); \
384 } while (0)
385
386 #define VERT_COPY_SPEC( v0, v1 ) \
387 do { \
388 v0->v.specular.red = v1->v.specular.red; \
389 v0->v.specular.green = v1->v.specular.green; \
390 v0->v.specular.blue = v1->v.specular.blue; \
391 } while (0)
392
393 #define VERT_SAVE_RGBA( idx ) color[idx] = v[idx]->ui[4]
394 #define VERT_RESTORE_RGBA( idx ) v[idx]->ui[4] = color[idx]
395 #define VERT_SAVE_SPEC( idx ) spec[idx] = v[idx]->ui[5]
396 #define VERT_RESTORE_SPEC( idx ) v[idx]->ui[5] = spec[idx]
397
398 #define LOCAL_VARS(n) \
399 mgaContextPtr mmesa = MGA_CONTEXT(ctx); \
400 GLuint color[n] = { 0 }; \
401 GLuint spec[n] = { 0 }; \
402 (void) color; (void) spec;
403
404
405
406 /***********************************************************************
407 * Functions to draw basic unfilled primitives *
408 ***********************************************************************/
409
410 #define RASTERIZE(x) if (mmesa->raster_primitive != x) \
411 mgaRasterPrimitive( ctx, x, MGA_WA_TRIANGLES )
412 #define RENDER_PRIMITIVE mmesa->render_primitive
413 #define IND MGA_FALLBACK_BIT
414 #define TAG(x) x
415 #include "tnl_dd/t_dd_unfilled.h"
416 #undef IND
417
418 /***********************************************************************
419 * Functions to draw GL primitives *
420 ***********************************************************************/
421
422 #define IND (0)
423 #define TAG(x) x
424 #include "tnl_dd/t_dd_tritmp.h"
425
426 #define IND (MGA_OFFSET_BIT)
427 #define TAG(x) x##_offset
428 #include "tnl_dd/t_dd_tritmp.h"
429
430 #define IND (MGA_TWOSIDE_BIT)
431 #define TAG(x) x##_twoside
432 #include "tnl_dd/t_dd_tritmp.h"
433
434 #define IND (MGA_TWOSIDE_BIT|MGA_OFFSET_BIT)
435 #define TAG(x) x##_twoside_offset
436 #include "tnl_dd/t_dd_tritmp.h"
437
438 #define IND (MGA_UNFILLED_BIT)
439 #define TAG(x) x##_unfilled
440 #include "tnl_dd/t_dd_tritmp.h"
441
442 #define IND (MGA_OFFSET_BIT|MGA_UNFILLED_BIT)
443 #define TAG(x) x##_offset_unfilled
444 #include "tnl_dd/t_dd_tritmp.h"
445
446 #define IND (MGA_TWOSIDE_BIT|MGA_UNFILLED_BIT)
447 #define TAG(x) x##_twoside_unfilled
448 #include "tnl_dd/t_dd_tritmp.h"
449
450 #define IND (MGA_TWOSIDE_BIT|MGA_OFFSET_BIT|MGA_UNFILLED_BIT)
451 #define TAG(x) x##_twoside_offset_unfilled
452 #include "tnl_dd/t_dd_tritmp.h"
453
454 #define IND (MGA_FALLBACK_BIT)
455 #define TAG(x) x##_fallback
456 #include "tnl_dd/t_dd_tritmp.h"
457
458 #define IND (MGA_OFFSET_BIT|MGA_FALLBACK_BIT)
459 #define TAG(x) x##_offset_fallback
460 #include "tnl_dd/t_dd_tritmp.h"
461
462 #define IND (MGA_TWOSIDE_BIT|MGA_FALLBACK_BIT)
463 #define TAG(x) x##_twoside_fallback
464 #include "tnl_dd/t_dd_tritmp.h"
465
466 #define IND (MGA_TWOSIDE_BIT|MGA_OFFSET_BIT|MGA_FALLBACK_BIT)
467 #define TAG(x) x##_twoside_offset_fallback
468 #include "tnl_dd/t_dd_tritmp.h"
469
470 #define IND (MGA_UNFILLED_BIT|MGA_FALLBACK_BIT)
471 #define TAG(x) x##_unfilled_fallback
472 #include "tnl_dd/t_dd_tritmp.h"
473
474 #define IND (MGA_OFFSET_BIT|MGA_UNFILLED_BIT|MGA_FALLBACK_BIT)
475 #define TAG(x) x##_offset_unfilled_fallback
476 #include "tnl_dd/t_dd_tritmp.h"
477
478 #define IND (MGA_TWOSIDE_BIT|MGA_UNFILLED_BIT|MGA_FALLBACK_BIT)
479 #define TAG(x) x##_twoside_unfilled_fallback
480 #include "tnl_dd/t_dd_tritmp.h"
481
482 #define IND (MGA_TWOSIDE_BIT|MGA_OFFSET_BIT|MGA_UNFILLED_BIT| \
483 MGA_FALLBACK_BIT)
484 #define TAG(x) x##_twoside_offset_unfilled_fallback
485 #include "tnl_dd/t_dd_tritmp.h"
486
487
488 /* Mga doesn't support provoking-vertex flat-shading?
489 */
490 #define IND (MGA_FLAT_BIT)
491 #define TAG(x) x##_flat
492 #include "tnl_dd/t_dd_tritmp.h"
493
494 #define IND (MGA_OFFSET_BIT|MGA_FLAT_BIT)
495 #define TAG(x) x##_offset_flat
496 #include "tnl_dd/t_dd_tritmp.h"
497
498 #define IND (MGA_TWOSIDE_BIT|MGA_FLAT_BIT)
499 #define TAG(x) x##_twoside_flat
500 #include "tnl_dd/t_dd_tritmp.h"
501
502 #define IND (MGA_TWOSIDE_BIT|MGA_OFFSET_BIT|MGA_FLAT_BIT)
503 #define TAG(x) x##_twoside_offset_flat
504 #include "tnl_dd/t_dd_tritmp.h"
505
506 #define IND (MGA_UNFILLED_BIT|MGA_FLAT_BIT)
507 #define TAG(x) x##_unfilled_flat
508 #include "tnl_dd/t_dd_tritmp.h"
509
510 #define IND (MGA_OFFSET_BIT|MGA_UNFILLED_BIT|MGA_FLAT_BIT)
511 #define TAG(x) x##_offset_unfilled_flat
512 #include "tnl_dd/t_dd_tritmp.h"
513
514 #define IND (MGA_TWOSIDE_BIT|MGA_UNFILLED_BIT|MGA_FLAT_BIT)
515 #define TAG(x) x##_twoside_unfilled_flat
516 #include "tnl_dd/t_dd_tritmp.h"
517
518 #define IND (MGA_TWOSIDE_BIT|MGA_OFFSET_BIT|MGA_UNFILLED_BIT|MGA_FLAT_BIT)
519 #define TAG(x) x##_twoside_offset_unfilled_flat
520 #include "tnl_dd/t_dd_tritmp.h"
521
522 #define IND (MGA_FALLBACK_BIT|MGA_FLAT_BIT)
523 #define TAG(x) x##_fallback_flat
524 #include "tnl_dd/t_dd_tritmp.h"
525
526 #define IND (MGA_OFFSET_BIT|MGA_FALLBACK_BIT|MGA_FLAT_BIT)
527 #define TAG(x) x##_offset_fallback_flat
528 #include "tnl_dd/t_dd_tritmp.h"
529
530 #define IND (MGA_TWOSIDE_BIT|MGA_FALLBACK_BIT|MGA_FLAT_BIT)
531 #define TAG(x) x##_twoside_fallback_flat
532 #include "tnl_dd/t_dd_tritmp.h"
533
534 #define IND (MGA_TWOSIDE_BIT|MGA_OFFSET_BIT|MGA_FALLBACK_BIT|MGA_FLAT_BIT)
535 #define TAG(x) x##_twoside_offset_fallback_flat
536 #include "tnl_dd/t_dd_tritmp.h"
537
538 #define IND (MGA_UNFILLED_BIT|MGA_FALLBACK_BIT|MGA_FLAT_BIT)
539 #define TAG(x) x##_unfilled_fallback_flat
540 #include "tnl_dd/t_dd_tritmp.h"
541
542 #define IND (MGA_OFFSET_BIT|MGA_UNFILLED_BIT|MGA_FALLBACK_BIT|MGA_FLAT_BIT)
543 #define TAG(x) x##_offset_unfilled_fallback_flat
544 #include "tnl_dd/t_dd_tritmp.h"
545
546 #define IND (MGA_TWOSIDE_BIT|MGA_UNFILLED_BIT|MGA_FALLBACK_BIT|MGA_FLAT_BIT)
547 #define TAG(x) x##_twoside_unfilled_fallback_flat
548 #include "tnl_dd/t_dd_tritmp.h"
549
550 #define IND (MGA_TWOSIDE_BIT|MGA_OFFSET_BIT|MGA_UNFILLED_BIT| \
551 MGA_FALLBACK_BIT|MGA_FLAT_BIT)
552 #define TAG(x) x##_twoside_offset_unfilled_fallback_flat
553 #include "tnl_dd/t_dd_tritmp.h"
554
555
556 static void init_rast_tab( void )
557 {
558 init();
559 init_offset();
560 init_twoside();
561 init_twoside_offset();
562 init_unfilled();
563 init_offset_unfilled();
564 init_twoside_unfilled();
565 init_twoside_offset_unfilled();
566 init_fallback();
567 init_offset_fallback();
568 init_twoside_fallback();
569 init_twoside_offset_fallback();
570 init_unfilled_fallback();
571 init_offset_unfilled_fallback();
572 init_twoside_unfilled_fallback();
573 init_twoside_offset_unfilled_fallback();
574
575 init_flat();
576 init_offset_flat();
577 init_twoside_flat();
578 init_twoside_offset_flat();
579 init_unfilled_flat();
580 init_offset_unfilled_flat();
581 init_twoside_unfilled_flat();
582 init_twoside_offset_unfilled_flat();
583 init_fallback_flat();
584 init_offset_fallback_flat();
585 init_twoside_fallback_flat();
586 init_twoside_offset_fallback_flat();
587 init_unfilled_fallback_flat();
588 init_offset_unfilled_fallback_flat();
589 init_twoside_unfilled_fallback_flat();
590 init_twoside_offset_unfilled_fallback_flat();
591 }
592
593 /**********************************************************************/
594 /* Render whole begin/end objects */
595 /**********************************************************************/
596
597
598 #define VERT(x) (mgaVertex *)(vertptr + ((x)*vertex_size*sizeof(int)))
599 #define RENDER_POINTS( start, count ) \
600 for ( ; start < count ; start++) \
601 mga_draw_point( mmesa, VERT(ELT(start)) );
602 #define RENDER_LINE( v0, v1 ) \
603 mga_draw_line( mmesa, VERT(v0), VERT(v1) )
604 #define RENDER_TRI( v0, v1, v2 ) \
605 mga_draw_triangle( mmesa, VERT(v0), VERT(v1), VERT(v2) )
606 #define RENDER_QUAD( v0, v1, v2, v3 ) \
607 mga_draw_quad( mmesa, VERT(v0), VERT(v1), VERT(v2), VERT(v3) )
608 #define INIT(x) mgaRenderPrimitive( ctx, x )
609 #undef LOCAL_VARS
610 #define LOCAL_VARS \
611 mgaContextPtr mmesa = MGA_CONTEXT(ctx); \
612 GLubyte *vertptr = (GLubyte *)mmesa->verts; \
613 const GLuint vertex_size = mmesa->vertex_size; \
614 const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts; \
615 (void) elt;
616 #define RESET_STIPPLE
617 #define RESET_OCCLUSION
618 #define PRESERVE_VB_DEFS
619 #define ELT(x) x
620 #define TAG(x) mga_##x##_verts
621 #include "tnl/t_vb_rendertmp.h"
622 #undef ELT
623 #undef TAG
624 #define TAG(x) mga_##x##_elts
625 #define ELT(x) elt[x]
626 #include "tnl/t_vb_rendertmp.h"
627
628
629 /**********************************************************************/
630 /* Render clipped primitives */
631 /**********************************************************************/
632
633
634
635 static void mgaRenderClippedPoly( GLcontext *ctx, const GLuint *elts, GLuint n )
636 {
637 mgaContextPtr mmesa = MGA_CONTEXT(ctx);
638 TNLcontext *tnl = TNL_CONTEXT(ctx);
639 struct vertex_buffer *VB = &tnl->vb;
640 GLuint prim = mmesa->render_primitive;
641
642 /* Render the new vertices as an unclipped polygon.
643 */
644 {
645 GLuint *tmp = VB->Elts;
646 VB->Elts = (GLuint *)elts;
647 tnl->Driver.Render.PrimTabElts[GL_POLYGON]( ctx, 0, n, PRIM_BEGIN|PRIM_END );
648 VB->Elts = tmp;
649 }
650
651 /* Restore the render primitive
652 */
653 if (prim != GL_POLYGON)
654 tnl->Driver.Render.PrimitiveNotify( ctx, prim );
655 }
656
657 static void mgaRenderClippedLine( GLcontext *ctx, GLuint ii, GLuint jj )
658 {
659 TNLcontext *tnl = TNL_CONTEXT(ctx);
660 tnl->Driver.Render.Line( ctx, ii, jj );
661 }
662
663 static void mgaFastRenderClippedPoly( GLcontext *ctx, const GLuint *elts,
664 GLuint n )
665 {
666 mgaContextPtr mmesa = MGA_CONTEXT( ctx );
667 GLuint vertex_size = mmesa->vertex_size;
668 GLuint *vb = mgaAllocDmaLow( mmesa, (n-2) * 3 * 4 * vertex_size );
669 GLubyte *vertptr = (GLubyte *)mmesa->verts;
670 const GLuint *start = (const GLuint *)VERT(elts[0]);
671 int i,j;
672
673 for (i = 2 ; i < n ; i++) {
674 EMIT_VERT( j, vb, vertex_size, (mgaVertexPtr) VERT(elts[i-1]) );
675 EMIT_VERT( j, vb, vertex_size, (mgaVertexPtr) VERT(elts[i]) );
676 EMIT_VERT( j, vb, vertex_size, (mgaVertexPtr) start );
677 }
678 }
679
680 /**********************************************************************/
681 /* Choose render functions */
682 /**********************************************************************/
683
684
685 #define POINT_FALLBACK (DD_POINT_SMOOTH)
686 #define LINE_FALLBACK (DD_LINE_SMOOTH | DD_LINE_STIPPLE)
687 #define TRI_FALLBACK (DD_TRI_SMOOTH | DD_TRI_UNFILLED)
688 #define ANY_FALLBACK_FLAGS (POINT_FALLBACK|LINE_FALLBACK|TRI_FALLBACK)
689 #define ANY_RASTER_FLAGS (DD_FLATSHADE|DD_TRI_LIGHT_TWOSIDE|DD_TRI_OFFSET| \
690 DD_TRI_UNFILLED)
691
692 void mgaChooseRenderState(GLcontext *ctx)
693 {
694 TNLcontext *tnl = TNL_CONTEXT(ctx);
695 mgaContextPtr mmesa = MGA_CONTEXT(ctx);
696 GLuint flags = ctx->_TriangleCaps;
697 GLuint index = 0;
698
699 if (flags & (ANY_FALLBACK_FLAGS|ANY_RASTER_FLAGS|DD_TRI_STIPPLE)) {
700 if (flags & ANY_RASTER_FLAGS) {
701 if (flags & DD_TRI_LIGHT_TWOSIDE) index |= MGA_TWOSIDE_BIT;
702 if (flags & DD_TRI_OFFSET) index |= MGA_OFFSET_BIT;
703 if (flags & DD_TRI_UNFILLED) index |= MGA_UNFILLED_BIT;
704 if (flags & DD_FLATSHADE) index |= MGA_FLAT_BIT;
705 }
706
707 mmesa->draw_point = mga_draw_point;
708 mmesa->draw_line = mga_draw_line;
709 mmesa->draw_tri = mga_draw_triangle;
710
711 /* Hook in fallbacks for specific primitives.
712 */
713 if (flags & ANY_FALLBACK_FLAGS)
714 {
715 if (flags & POINT_FALLBACK)
716 mmesa->draw_point = mga_fallback_point;
717
718 if (flags & LINE_FALLBACK)
719 mmesa->draw_line = mga_fallback_line;
720
721 if (flags & TRI_FALLBACK)
722 mmesa->draw_tri = mga_fallback_tri;
723
724 index |= MGA_FALLBACK_BIT;
725 }
726
727 if ((flags & DD_TRI_STIPPLE) && !mmesa->haveHwStipple) {
728 mmesa->draw_tri = mga_fallback_tri;
729 index |= MGA_FALLBACK_BIT;
730 }
731 }
732
733 if (mmesa->RenderIndex != index) {
734 mmesa->RenderIndex = index;
735
736 tnl->Driver.Render.Points = rast_tab[index].points;
737 tnl->Driver.Render.Line = rast_tab[index].line;
738 tnl->Driver.Render.Triangle = rast_tab[index].triangle;
739 tnl->Driver.Render.Quad = rast_tab[index].quad;
740
741 if (index == 0) {
742 tnl->Driver.Render.PrimTabVerts = mga_render_tab_verts;
743 tnl->Driver.Render.PrimTabElts = mga_render_tab_elts;
744 tnl->Driver.Render.ClippedLine = line; /* from tritmp.h */
745 tnl->Driver.Render.ClippedPolygon = mgaFastRenderClippedPoly;
746 } else {
747 tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
748 tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
749 tnl->Driver.Render.ClippedLine = mgaRenderClippedLine;
750 tnl->Driver.Render.ClippedPolygon = mgaRenderClippedPoly;
751 }
752 }
753 }
754
755 /**********************************************************************/
756 /* Runtime render state and callbacks */
757 /**********************************************************************/
758
759
760 static GLenum reduced_prim[GL_POLYGON+1] = {
761 GL_POINTS,
762 GL_LINES,
763 GL_LINES,
764 GL_LINES,
765 GL_TRIANGLES,
766 GL_TRIANGLES,
767 GL_TRIANGLES,
768 GL_TRIANGLES,
769 GL_TRIANGLES,
770 GL_TRIANGLES
771 };
772
773
774
775 /* Always called between RenderStart and RenderFinish --> We already
776 * hold the lock.
777 */
778 void mgaRasterPrimitive( GLcontext *ctx, GLenum prim, GLuint hwprim )
779 {
780 mgaContextPtr mmesa = MGA_CONTEXT( ctx );
781
782 FLUSH_BATCH( mmesa );
783
784 /* Update culling */
785 if (mmesa->raster_primitive != prim)
786 mmesa->dirty |= MGA_UPLOAD_CONTEXT;
787
788 mmesa->raster_primitive = prim;
789 /* mmesa->hw_primitive = hwprim; */
790 mmesa->hw_primitive = MGA_WA_TRIANGLES; /* disable mgarender.c for now */
791
792 if (ctx->Polygon.StippleFlag && mmesa->haveHwStipple)
793 {
794 mmesa->dirty |= MGA_UPLOAD_CONTEXT;
795 mmesa->setup.dwgctl &= ~(0xf<<20);
796 if (mmesa->raster_primitive == GL_TRIANGLES)
797 mmesa->setup.dwgctl |= mmesa->poly_stipple;
798 }
799 }
800
801
802
803 /* Determine the rasterized primitive when not drawing unfilled
804 * polygons.
805 *
806 * Used only for the default render stage which always decomposes
807 * primitives to trianges/lines/points. For the accelerated stage,
808 * which renders strips as strips, the equivalent calculations are
809 * performed in mgarender.c.
810 */
811 static void mgaRenderPrimitive( GLcontext *ctx, GLenum prim )
812 {
813 mgaContextPtr mmesa = MGA_CONTEXT(ctx);
814 GLuint rprim = reduced_prim[prim];
815
816 mmesa->render_primitive = prim;
817
818 if (rprim == GL_TRIANGLES && (ctx->_TriangleCaps & DD_TRI_UNFILLED))
819 return;
820
821 if (mmesa->raster_primitive != rprim) {
822 mgaRasterPrimitive( ctx, rprim, MGA_WA_TRIANGLES );
823 }
824 }
825
826 static void mgaRenderFinish( GLcontext *ctx )
827 {
828 if (MGA_CONTEXT(ctx)->RenderIndex & MGA_FALLBACK_BIT)
829 _swrast_flush( ctx );
830 }
831
832
833
834 /**********************************************************************/
835 /* Manage total rasterization fallbacks */
836 /**********************************************************************/
837
838 static const char * const fallbackStrings[] = {
839 "Texture mode",
840 "glDrawBuffer(GL_FRONT_AND_BACK)",
841 "read buffer",
842 "glBlendFunc(GL_SRC_ALPHA_SATURATE, GL_ZERO)",
843 "glRenderMode(selection or feedback)",
844 "No hardware stencil",
845 "glDepthFunc( GL_NEVER )",
846 "Mixing GL_CLAMP_TO_EDGE and GL_CLAMP",
847 "rasterization fallback option"
848 };
849
850 static const char *getFallbackString(GLuint bit)
851 {
852 int i = 0;
853 while (bit > 1) {
854 i++;
855 bit >>= 1;
856 }
857 return fallbackStrings[i];
858 }
859
860
861 void mgaFallback( GLcontext *ctx, GLuint bit, GLboolean mode )
862 {
863 TNLcontext *tnl = TNL_CONTEXT(ctx);
864 mgaContextPtr mmesa = MGA_CONTEXT(ctx);
865 GLuint oldfallback = mmesa->Fallback;
866
867 if (mode) {
868 mmesa->Fallback |= bit;
869 if (oldfallback == 0) {
870 FLUSH_BATCH(mmesa);
871 _swsetup_Wakeup( ctx );
872 mmesa->RenderIndex = ~0;
873 if (MGA_DEBUG & DEBUG_VERBOSE_FALLBACK) {
874 fprintf(stderr, "MGA begin rasterization fallback: 0x%x %s\n",
875 bit, getFallbackString(bit));
876 }
877 }
878 }
879 else {
880 mmesa->Fallback &= ~bit;
881 if (oldfallback == bit) {
882 _swrast_flush( ctx );
883 tnl->Driver.Render.Start = mgaCheckTexSizes;
884 tnl->Driver.Render.PrimitiveNotify = mgaRenderPrimitive;
885 tnl->Driver.Render.Finish = mgaRenderFinish;
886 tnl->Driver.Render.BuildVertices = mgaBuildVertices;
887 mmesa->NewGLState |= (_MGA_NEW_RENDERSTATE |
888 _MGA_NEW_RASTERSETUP);
889 if (MGA_DEBUG & DEBUG_VERBOSE_FALLBACK) {
890 fprintf(stderr, "MGA end rasterization fallback: 0x%x %s\n",
891 bit, getFallbackString(bit));
892 }
893 }
894 }
895 }
896
897
898 void mgaDDInitTriFuncs( GLcontext *ctx )
899 {
900 TNLcontext *tnl = TNL_CONTEXT(ctx);
901 mgaContextPtr mmesa = MGA_CONTEXT(ctx);
902 static int firsttime = 1;
903 if (firsttime) {
904 init_rast_tab();
905 firsttime = 0;
906 }
907
908 mmesa->RenderIndex = ~0;
909
910 tnl->Driver.Render.Start = mgaCheckTexSizes;
911 tnl->Driver.Render.Finish = mgaRenderFinish;
912 tnl->Driver.Render.PrimitiveNotify = mgaRenderPrimitive;
913 tnl->Driver.Render.ResetLineStipple = _swrast_ResetLineStipple;
914 tnl->Driver.Render.BuildVertices = mgaBuildVertices;
915 tnl->Driver.Render.Multipass = NULL;
916 }