projects / mesa.git / blob
? search:


4f9a9647716e0596543d79e9b30ab2e1b72cda99
[mesa.git] / src / mesa / drivers / dri / unichrome / via_tris.c
1 /*
2 * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
3 * Copyright 2001-2003 S3 Graphics, Inc. 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 * the rights to use, copy, modify, merge, publish, distribute, sub license,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the
13 * next paragraph) shall be included in all copies or substantial portions
14 * of the 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 * VIA, S3 GRAPHICS, 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 OTHER
22 * DEALINGS IN THE SOFTWARE.
23 */
24
25 #include <stdio.h>
26 #include <math.h>
27
28 #include "glheader.h"
29 #include "context.h"
30 #include "mtypes.h"
31 #include "macros.h"
32 #include "colormac.h"
33 #include "enums.h"
34
35 #include "swrast/swrast.h"
36 #include "swrast_setup/swrast_setup.h"
37 #include "tnl/t_context.h"
38 #include "tnl/t_pipeline.h"
39
40 #include "via_context.h"
41 #include "via_tris.h"
42 #include "via_state.h"
43 #include "via_vb.h"
44 #include "via_ioctl.h"
45
46 /***********************************************************************
47 * Emit primitives as inline vertices *
48 ***********************************************************************/
49
50 #if 0
51 #define COPY_DWORDS(vb, vertsize, v) \
52 do { \
53 int j; \
54 int __tmp; \
55 __asm__ __volatile__("rep ; movsl" \
56 : "=%c" (j), "=D" (vb), "=S" (__tmp) \
57 : "0" (vertsize), \
58 "D" ((long)vb), \
59 "S" ((long)v)); \
60 } while (0)
61 #else
62 #define COPY_DWORDS(vb, vertsize, v) \
63 do { \
64 int j; \
65 for (j = 0; j < vertsize; j++) \
66 vb[j] = ((GLuint *)v)[j]; \
67 vb += vertsize; \
68 } while (0)
69 #endif
70
71 static void __inline__ via_draw_triangle(viaContextPtr vmesa,
72 viaVertexPtr v0,
73 viaVertexPtr v1,
74 viaVertexPtr v2)
75 {
76 GLuint vertsize = vmesa->vertexSize;
77 GLuint *vb = viaAllocDma(vmesa, 3 * 4 * vertsize);
78 /* fprintf(stderr, "%s: %p %p %p\n", __FUNCTION__, v0, v1, v2); */
79 COPY_DWORDS(vb, vertsize, v0);
80 COPY_DWORDS(vb, vertsize, v1);
81 COPY_DWORDS(vb, vertsize, v2);
82 }
83
84
85 static void __inline__ via_draw_quad(viaContextPtr vmesa,
86 viaVertexPtr v0,
87 viaVertexPtr v1,
88 viaVertexPtr v2,
89 viaVertexPtr v3)
90 {
91 GLuint vertsize = vmesa->vertexSize;
92 GLuint *vb = viaAllocDma(vmesa, 6 * 4 * vertsize);
93
94 /* fprintf(stderr, "%s: %p %p %p %p\n", __FUNCTION__, v0, v1, v2, v3); */
95 COPY_DWORDS(vb, vertsize, v0);
96 COPY_DWORDS(vb, vertsize, v1);
97 COPY_DWORDS(vb, vertsize, v3);
98 COPY_DWORDS(vb, vertsize, v1);
99 COPY_DWORDS(vb, vertsize, v2);
100 COPY_DWORDS(vb, vertsize, v3);
101 }
102
103 static __inline__ void via_draw_line(viaContextPtr vmesa,
104 viaVertexPtr v0,
105 viaVertexPtr v1)
106 {
107 GLuint vertsize = vmesa->vertexSize;
108 GLuint *vb = viaAllocDma(vmesa, 2 * 4 * vertsize);
109 COPY_DWORDS(vb, vertsize, v0);
110 COPY_DWORDS(vb, vertsize, v1);
111 }
112
113
114 static __inline__ void via_draw_point(viaContextPtr vmesa,
115 viaVertexPtr v0)
116 {
117 GLuint vertsize = vmesa->vertexSize;
118 GLuint *vb = viaAllocDma(vmesa, 4 * vertsize);
119 COPY_DWORDS(vb, vertsize, v0);
120 }
121
122
123
124
125 /***********************************************************************
126 * Macros for via_dd_tritmp.h to draw basic primitives *
127 ***********************************************************************/
128
129 #define TRI(a, b, c) \
130 do { \
131 if (VIA_DEBUG) fprintf(stderr, "hw TRI\n"); \
132 if (DO_FALLBACK) \
133 vmesa->drawTri(vmesa, a, b, c); \
134 else \
135 via_draw_triangle(vmesa, a, b, c); \
136 } while (0)
137
138 #define QUAD(a, b, c, d) \
139 do { \
140 if (VIA_DEBUG) fprintf(stderr, "hw QUAD\n");\
141 if (DO_FALLBACK) { \
142 vmesa->drawTri(vmesa, a, b, d); \
143 vmesa->drawTri(vmesa, b, c, d); \
144 } \
145 else \
146 via_draw_quad(vmesa, a, b, c, d); \
147 } while (0)
148
149 #define LINE(v0, v1) \
150 do { \
151 if(VIA_DEBUG) fprintf(stderr, "hw LINE\n");\
152 if (DO_FALLBACK) \
153 vmesa->drawLine(vmesa, v0, v1); \
154 else \
155 via_draw_line(vmesa, v0, v1); \
156 } while (0)
157
158 #define POINT(v0) \
159 do { \
160 if (VIA_DEBUG) fprintf(stderr, "hw POINT\n");\
161 if (DO_FALLBACK) \
162 vmesa->drawPoint(vmesa, v0); \
163 else \
164 via_draw_point(vmesa, v0); \
165 } while (0)
166
167
168 /***********************************************************************
169 * Build render functions from dd templates *
170 ***********************************************************************/
171
172 #define VIA_OFFSET_BIT 0x01
173 #define VIA_TWOSIDE_BIT 0x02
174 #define VIA_UNFILLED_BIT 0x04
175 #define VIA_FALLBACK_BIT 0x08
176 #define VIA_MAX_TRIFUNC 0x10
177
178
179 static struct {
180 tnl_points_func points;
181 tnl_line_func line;
182 tnl_triangle_func triangle;
183 tnl_quad_func quad;
184 } rast_tab[VIA_MAX_TRIFUNC];
185
186
187 #define DO_FALLBACK (IND & VIA_FALLBACK_BIT)
188 #define DO_OFFSET (IND & VIA_OFFSET_BIT)
189 #define DO_UNFILLED (IND & VIA_UNFILLED_BIT)
190 #define DO_TWOSIDE (IND & VIA_TWOSIDE_BIT)
191 #define DO_FLAT 0
192 #define DO_TRI 1
193 #define DO_QUAD 1
194 #define DO_LINE 1
195 #define DO_POINTS 1
196 #define DO_FULL_QUAD 1
197
198 #define HAVE_RGBA 1
199 #define HAVE_SPEC 1
200 #define HAVE_BACK_COLORS 0
201 #define HAVE_HW_FLATSHADE 1
202 #define VERTEX viaVertex
203 #define TAB rast_tab
204
205 /* Only used to pull back colors into vertices (ie, we know color is
206 * floating point).
207 */
208 #define VIA_COLOR(dst, src) \
209 do { \
210 dst[0] = src[2]; \
211 dst[1] = src[1]; \
212 dst[2] = src[0]; \
213 dst[3] = src[3]; \
214 } while (0)
215
216 #define VIA_SPEC(dst, src) \
217 do { \
218 dst[0] = src[2]; \
219 dst[1] = src[1]; \
220 dst[2] = src[0]; \
221 } while (0)
222
223
224 #define DEPTH_SCALE (1.0 / 0xffff)
225 #define UNFILLED_TRI unfilled_tri
226 #define UNFILLED_QUAD unfilled_quad
227 #define VERT_X(_v) _v->v.x
228 #define VERT_Y(_v) _v->v.y
229 #define VERT_Z(_v) _v->v.z
230 #define AREA_IS_CCW(a) (a > 0)
231 #define GET_VERTEX(e) (vmesa->verts + (e * vmesa->vertexSize * sizeof(int)))
232
233 #define VERT_SET_RGBA( v, c ) \
234 do { \
235 via_color_t *color = (via_color_t *)&((v)->ui[coloroffset]); \
236 UNCLAMPED_FLOAT_TO_UBYTE(color->red, (c)[0]); \
237 UNCLAMPED_FLOAT_TO_UBYTE(color->green, (c)[1]); \
238 UNCLAMPED_FLOAT_TO_UBYTE(color->blue, (c)[2]); \
239 UNCLAMPED_FLOAT_TO_UBYTE(color->alpha, (c)[3]); \
240 } while (0)
241
242 #define VERT_COPY_RGBA( v0, v1 ) v0->ui[coloroffset] = v1->ui[coloroffset]
243
244 #define VERT_SET_SPEC( v0, c ) \
245 do { \
246 if (havespec) { \
247 UNCLAMPED_FLOAT_TO_UBYTE(v0->v.specular.red, (c)[0]); \
248 UNCLAMPED_FLOAT_TO_UBYTE(v0->v.specular.green, (c)[1]); \
249 UNCLAMPED_FLOAT_TO_UBYTE(v0->v.specular.blue, (c)[2]); \
250 } \
251 } while (0)
252 #define VERT_COPY_SPEC( v0, v1 ) \
253 do { \
254 if (havespec) { \
255 v0->v.specular.red = v1->v.specular.red; \
256 v0->v.specular.green = v1->v.specular.green; \
257 v0->v.specular.blue = v1->v.specular.blue; \
258 } \
259 } while (0)
260
261
262 #define VERT_SAVE_RGBA( idx ) color[idx] = v[idx]->ui[coloroffset]
263 #define VERT_RESTORE_RGBA( idx ) v[idx]->ui[coloroffset] = color[idx]
264 #define VERT_SAVE_SPEC( idx ) if (havespec) spec[idx] = v[idx]->ui[5]
265 #define VERT_RESTORE_SPEC( idx ) if (havespec) v[idx]->ui[5] = spec[idx]
266
267
268 #define LOCAL_VARS(n) \
269 viaContextPtr vmesa = VIA_CONTEXT(ctx); \
270 GLuint color[n], spec[n]; \
271 GLuint coloroffset = (vmesa->vertexSize == 4 ? 3 : 4); \
272 GLboolean havespec = (vmesa->vertexSize > 4); \
273 (void)color; (void)spec; (void)coloroffset; (void)havespec;
274
275
276 /***********************************************************************
277 * Helpers for rendering unfilled primitives *
278 ***********************************************************************/
279
280 static const GLenum hwPrim[GL_POLYGON + 1] = {
281 GL_POINTS,
282 GL_LINES,
283 GL_LINES,
284 GL_LINES,
285 GL_TRIANGLES,
286 GL_TRIANGLES,
287 GL_TRIANGLES,
288 GL_TRIANGLES,
289 GL_TRIANGLES,
290 GL_TRIANGLES
291 };
292
293
294 #define RASTERIZE(x) viaRasterPrimitive( ctx, x, hwPrim[x] )
295 #define RENDER_PRIMITIVE vmesa->renderPrimitive
296 #define TAG(x) x
297 #define IND VIA_FALLBACK_BIT
298 #include "tnl_dd/t_dd_unfilled.h"
299 #undef IND
300 #undef RASTERIZE
301
302 /***********************************************************************
303 * Generate GL render functions *
304 ***********************************************************************/
305 #define RASTERIZE(x)
306
307 #define IND (0)
308 #define TAG(x) x
309 #include "tnl_dd/t_dd_tritmp.h"
310
311 #define IND (VIA_OFFSET_BIT)
312 #define TAG(x) x##_offset
313 #include "tnl_dd/t_dd_tritmp.h"
314
315 #define IND (VIA_TWOSIDE_BIT)
316 #define TAG(x) x##_twoside
317 #include "tnl_dd/t_dd_tritmp.h"
318
319 #define IND (VIA_TWOSIDE_BIT|VIA_OFFSET_BIT)
320 #define TAG(x) x##_twoside_offset
321 #include "tnl_dd/t_dd_tritmp.h"
322
323 #define IND (VIA_UNFILLED_BIT)
324 #define TAG(x) x##_unfilled
325 #include "tnl_dd/t_dd_tritmp.h"
326
327 #define IND (VIA_OFFSET_BIT|VIA_UNFILLED_BIT)
328 #define TAG(x) x##_offset_unfilled
329 #include "tnl_dd/t_dd_tritmp.h"
330
331 #define IND (VIA_TWOSIDE_BIT|VIA_UNFILLED_BIT)
332 #define TAG(x) x##_twoside_unfilled
333 #include "tnl_dd/t_dd_tritmp.h"
334
335 #define IND (VIA_TWOSIDE_BIT|VIA_OFFSET_BIT|VIA_UNFILLED_BIT)
336 #define TAG(x) x##_twoside_offset_unfilled
337 #include "tnl_dd/t_dd_tritmp.h"
338
339 #define IND (VIA_FALLBACK_BIT)
340 #define TAG(x) x##_fallback
341 #include "tnl_dd/t_dd_tritmp.h"
342
343 #define IND (VIA_OFFSET_BIT|VIA_FALLBACK_BIT)
344 #define TAG(x) x##_offset_fallback
345 #include "tnl_dd/t_dd_tritmp.h"
346
347 #define IND (VIA_TWOSIDE_BIT|VIA_FALLBACK_BIT)
348 #define TAG(x) x##_twoside_fallback
349 #include "tnl_dd/t_dd_tritmp.h"
350
351 #define IND (VIA_TWOSIDE_BIT|VIA_OFFSET_BIT|VIA_FALLBACK_BIT)
352 #define TAG(x) x##_twoside_offset_fallback
353 #include "tnl_dd/t_dd_tritmp.h"
354
355 #define IND (VIA_UNFILLED_BIT|VIA_FALLBACK_BIT)
356 #define TAG(x) x##_unfilled_fallback
357 #include "tnl_dd/t_dd_tritmp.h"
358
359 #define IND (VIA_OFFSET_BIT|VIA_UNFILLED_BIT|VIA_FALLBACK_BIT)
360 #define TAG(x) x##_offset_unfilled_fallback
361 #include "tnl_dd/t_dd_tritmp.h"
362
363 #define IND (VIA_TWOSIDE_BIT|VIA_UNFILLED_BIT|VIA_FALLBACK_BIT)
364 #define TAG(x) x##_twoside_unfilled_fallback
365 #include "tnl_dd/t_dd_tritmp.h"
366
367 #define IND (VIA_TWOSIDE_BIT|VIA_OFFSET_BIT|VIA_UNFILLED_BIT| \
368 VIA_FALLBACK_BIT)
369 #define TAG(x) x##_twoside_offset_unfilled_fallback
370 #include "tnl_dd/t_dd_tritmp.h"
371
372
373 static void init_rast_tab(void)
374 {
375 init();
376 init_offset();
377 init_twoside();
378 init_twoside_offset();
379 init_unfilled();
380 init_offset_unfilled();
381 init_twoside_unfilled();
382 init_twoside_offset_unfilled();
383 init_fallback();
384 init_offset_fallback();
385 init_twoside_fallback();
386 init_twoside_offset_fallback();
387 init_unfilled_fallback();
388 init_offset_unfilled_fallback();
389 init_twoside_unfilled_fallback();
390 init_twoside_offset_unfilled_fallback();
391 }
392
393
394 /***********************************************************************
395 * Rasterization fallback helpers *
396 ***********************************************************************/
397
398
399 /* This code is hit only when a mix of accelerated and unaccelerated
400 * primitives are being drawn, and only for the unaccelerated
401 * primitives.
402 */
403 static void
404 via_fallback_tri(viaContextPtr vmesa,
405 viaVertex *v0,
406 viaVertex *v1,
407 viaVertex *v2)
408 {
409 GLcontext *ctx = vmesa->glCtx;
410 SWvertex v[3];
411 via_translate_vertex(ctx, v0, &v[0]);
412 via_translate_vertex(ctx, v1, &v[1]);
413 via_translate_vertex(ctx, v2, &v[2]);
414 _swrast_Triangle(ctx, &v[0], &v[1], &v[2]);
415 }
416
417
418 static void
419 via_fallback_line(viaContextPtr vmesa,
420 viaVertex *v0,
421 viaVertex *v1)
422 {
423 GLcontext *ctx = vmesa->glCtx;
424 SWvertex v[2];
425 via_translate_vertex(ctx, v0, &v[0]);
426 via_translate_vertex(ctx, v1, &v[1]);
427 _swrast_Line(ctx, &v[0], &v[1]);
428 }
429
430
431 static void
432 via_fallback_point(viaContextPtr vmesa,
433 viaVertex *v0)
434 {
435 GLcontext *ctx = vmesa->glCtx;
436 SWvertex v[1];
437 via_translate_vertex(ctx, v0, &v[0]);
438 _swrast_Point(ctx, &v[0]);
439 }
440
441 /**********************************************************************/
442 /* Render unclipped begin/end objects */
443 /**********************************************************************/
444 #define IND 0
445 #define V(x) (viaVertex *)(vertptr + ((x) * vertsize * sizeof(int)))
446 #define RENDER_POINTS(start, count) \
447 for (; start < count; start++) POINT(V(ELT(start)));
448 #define RENDER_LINE(v0, v1) LINE(V(v0), V(v1))
449 #define RENDER_TRI( v0, v1, v2) TRI( V(v0), V(v1), V(v2))
450 #define RENDER_QUAD(v0, v1, v2, v3) QUAD(V(v0), V(v1), V(v2), V(v3))
451 #define INIT(x) viaRasterPrimitive(ctx, x, hwPrim[x])
452 #undef LOCAL_VARS
453 #define LOCAL_VARS \
454 viaContextPtr vmesa = VIA_CONTEXT(ctx); \
455 GLubyte *vertptr = (GLubyte *)vmesa->verts; \
456 const GLuint vertsize = vmesa->vertexSize; \
457 const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts; \
458 (void)elt;
459 #define RESET_STIPPLE
460 #define RESET_OCCLUSION
461 #define PRESERVE_VB_DEFS
462 #define ELT(x) x
463 #define TAG(x) via_fast##x##_verts
464 #include "tnl/t_vb_rendertmp.h"
465 #undef ELT
466 #undef TAG
467 #define TAG(x) via_fast##x##_elts
468 #define ELT(x) elt[x]
469 #include "tnl/t_vb_rendertmp.h"
470 #undef ELT
471 #undef TAG
472 #undef NEED_EDGEFLAG_SETUP
473 #undef EDGEFLAG_GET
474 #undef EDGEFLAG_SET
475 #undef RESET_OCCLUSION
476
477
478 /**********************************************************************/
479 /* Render clipped primitives */
480 /**********************************************************************/
481
482
483
484 static void viaRenderClippedPoly(GLcontext *ctx, const GLuint *elts,
485 GLuint n)
486 {
487 TNLcontext *tnl = TNL_CONTEXT(ctx);
488 struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
489 GLuint prim = VIA_CONTEXT(ctx)->renderPrimitive;
490
491 /* Render the new vertices as an unclipped polygon.
492 */
493 {
494 GLuint *tmp = VB->Elts;
495 VB->Elts = (GLuint *)elts;
496 tnl->Driver.Render.PrimTabElts[GL_POLYGON](ctx, 0, n,
497 PRIM_BEGIN|PRIM_END);
498 VB->Elts = tmp;
499 }
500
501 /* Restore the render primitive
502 */
503 if (prim != GL_POLYGON)
504 tnl->Driver.Render.PrimitiveNotify( ctx, prim );
505 }
506
507 static void viaRenderClippedLine(GLcontext *ctx, GLuint ii, GLuint jj)
508 {
509 TNLcontext *tnl = TNL_CONTEXT(ctx);
510 tnl->Driver.Render.Line(ctx, ii, jj);
511 }
512
513 static void viaFastRenderClippedPoly(GLcontext *ctx, const GLuint *elts,
514 GLuint n)
515 {
516 viaContextPtr vmesa = VIA_CONTEXT(ctx);
517 GLuint vertsize = vmesa->vertexSize;
518 GLuint *vb = viaAllocDma(vmesa, (n - 2) * 3 * 4 * vertsize);
519 GLubyte *vertptr = (GLubyte *)vmesa->verts;
520 const GLuint *start = (const GLuint *)V(elts[0]);
521 int i;
522
523 for (i = 2; i < n; i++) {
524 COPY_DWORDS(vb, vertsize, V(elts[i - 1]));
525 COPY_DWORDS(vb, vertsize, V(elts[i]));
526 COPY_DWORDS(vb, vertsize, start);
527 }
528 }
529
530 /**********************************************************************/
531 /* Choose render functions */
532 /**********************************************************************/
533
534
535
536 #define _VIA_NEW_RENDERSTATE (_DD_NEW_LINE_STIPPLE | \
537 _DD_NEW_TRI_UNFILLED | \
538 _DD_NEW_TRI_LIGHT_TWOSIDE | \
539 _DD_NEW_TRI_OFFSET | \
540 _DD_NEW_TRI_STIPPLE | \
541 _NEW_POLYGONSTIPPLE)
542
543 #define POINT_FALLBACK (0)
544 /*#define LINE_FALLBACK (DD_LINE_STIPPLE)
545 */
546 #define LINE_FALLBACK (0)
547 #define TRI_FALLBACK (0)
548 #define ANY_FALLBACK_FLAGS (POINT_FALLBACK|LINE_FALLBACK|TRI_FALLBACK)
549 #define ANY_RASTER_FLAGS (DD_TRI_LIGHT_TWOSIDE|DD_TRI_OFFSET|DD_TRI_UNFILLED)
550
551 static void viaChooseRenderState(GLcontext *ctx)
552 {
553 TNLcontext *tnl = TNL_CONTEXT(ctx);
554 viaContextPtr vmesa = VIA_CONTEXT(ctx);
555 GLuint flags = ctx->_TriangleCaps;
556 GLuint index = 0;
557 if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
558
559 if (VIA_DEBUG) fprintf(stderr, "_TriangleCaps = %x\n", flags);
560 if (flags & (ANY_FALLBACK_FLAGS|ANY_RASTER_FLAGS)) {
561 if (flags & ANY_RASTER_FLAGS) {
562 if (flags & DD_TRI_LIGHT_TWOSIDE) index |= VIA_TWOSIDE_BIT;
563 if (flags & DD_TRI_OFFSET) index |= VIA_OFFSET_BIT;
564 if (flags & DD_TRI_UNFILLED) index |= VIA_UNFILLED_BIT;
565 }
566
567 vmesa->drawPoint = via_draw_point;
568 vmesa->drawLine = via_draw_line;
569 vmesa->drawTri = via_draw_triangle;
570
571 /* Hook in fallbacks for specific primitives.
572 */
573 if (flags & ANY_FALLBACK_FLAGS) {
574 if (flags & POINT_FALLBACK)
575 vmesa->drawPoint = via_fallback_point;
576
577 if (flags & LINE_FALLBACK)
578 vmesa->drawLine = via_fallback_line;
579
580 if (flags & TRI_FALLBACK)
581 vmesa->drawTri = via_fallback_tri;
582
583 index |= VIA_FALLBACK_BIT;
584 }
585 }
586 if (VIA_DEBUG) {
587 fprintf(stderr, "index = %x\n", index);
588 fprintf(stderr, "renderIndex = %x\n", vmesa->renderIndex);
589 }
590 if (vmesa->renderIndex != index) {
591 vmesa->renderIndex = index;
592
593 tnl->Driver.Render.Points = rast_tab[index].points;
594 tnl->Driver.Render.Line = rast_tab[index].line;
595 tnl->Driver.Render.Triangle = rast_tab[index].triangle;
596
597 tnl->Driver.Render.Quad = rast_tab[index].quad;
598
599 if (index == 0) {
600 tnl->Driver.Render.PrimTabVerts = via_fastrender_tab_verts;
601 tnl->Driver.Render.PrimTabElts = via_fastrender_tab_elts;
602 tnl->Driver.Render.ClippedLine = line; /* from tritmp.h */
603 tnl->Driver.Render.ClippedPolygon = viaFastRenderClippedPoly;
604 }
605 else {
606 tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
607 tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
608 tnl->Driver.Render.ClippedLine = viaRenderClippedLine;
609 tnl->Driver.Render.ClippedPolygon = viaRenderClippedPoly;
610 }
611 }
612 if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
613 }
614
615
616
617
618
619 /**********************************************************************/
620 /* High level hooks for t_vb_render.c */
621 /**********************************************************************/
622
623 static void viaRunPipeline(GLcontext *ctx)
624 {
625 viaContextPtr vmesa = VIA_CONTEXT(ctx);
626
627 if (vmesa->newState) {
628 viaValidateState( ctx );
629
630 if (!vmesa->Fallback) {
631 viaChooseVertexState(ctx);
632 viaChooseRenderState(ctx);
633 }
634 }
635
636 _tnl_run_pipeline(ctx);
637 }
638
639 static void viaRenderStart(GLcontext *ctx)
640 {
641 /* Check for projective texturing. Make sure all texcoord
642 * pointers point to something. (fix in mesa?)
643 */
644 viaCheckTexSizes(ctx);
645 }
646
647 static void viaRenderFinish(GLcontext *ctx)
648 {
649 if (VIA_CONTEXT(ctx)->renderIndex & VIA_FALLBACK_BIT)
650 _swrast_flush(ctx);
651 else
652 VIA_FINISH_PRIM(VIA_CONTEXT(ctx));
653 }
654
655
656
657 /* System to flush dma and emit state changes based on the rasterized
658 * primitive.
659 */
660 void viaRasterPrimitive(GLcontext *ctx,
661 GLenum glprim,
662 GLenum hwprim)
663 {
664 viaContextPtr vmesa = VIA_CONTEXT(ctx);
665 GLuint regCmdB;
666 RING_VARS;
667
668 if (VIA_DEBUG)
669 fprintf(stderr, "%s: %s/%s\n", __FUNCTION__, _mesa_lookup_enum_by_nr(glprim),
670 _mesa_lookup_enum_by_nr(hwprim));
671
672 VIA_FINISH_PRIM(vmesa);
673
674 vmesa->renderPrimitive = glprim;
675
676 regCmdB = vmesa->regCmdB;
677
678 switch (hwprim) {
679 case GL_POINTS:
680 vmesa->regCmdA_End = vmesa->regCmdA | HC_HPMType_Point | HC_HVCycle_Full;
681 if (ctx->Light.ShadeModel == GL_FLAT)
682 vmesa->regCmdA_End |= HC_HShading_FlatA;
683 break;
684 case GL_LINES:
685 vmesa->regCmdA_End = vmesa->regCmdA | HC_HPMType_Line | HC_HVCycle_Full;
686 if (ctx->Light.ShadeModel == GL_FLAT)
687 vmesa->regCmdA_End |= HC_HShading_FlatB;
688 break;
689 case GL_LINE_LOOP:
690 case GL_LINE_STRIP:
691 vmesa->regCmdA_End = vmesa->regCmdA | HC_HPMType_Line | HC_HVCycle_AFP |
692 HC_HVCycle_AB | HC_HVCycle_NewB;
693 regCmdB |= HC_HVCycle_AB | HC_HVCycle_NewB | HC_HLPrst_MASK;
694 if (ctx->Light.ShadeModel == GL_FLAT)
695 vmesa->regCmdA_End |= HC_HShading_FlatB;
696 break;
697 case GL_TRIANGLES:
698 vmesa->regCmdA_End = vmesa->regCmdA | HC_HPMType_Tri | HC_HVCycle_Full;
699 if (ctx->Light.ShadeModel == GL_FLAT)
700 vmesa->regCmdA_End |= HC_HShading_FlatC;
701 break;
702 case GL_TRIANGLE_STRIP:
703 vmesa->regCmdA_End = vmesa->regCmdA | HC_HPMType_Tri | HC_HVCycle_AFP |
704 HC_HVCycle_AC | HC_HVCycle_BB | HC_HVCycle_NewC;
705 regCmdB |= HC_HVCycle_AA | HC_HVCycle_BC | HC_HVCycle_NewC;
706 if (ctx->Light.ShadeModel == GL_FLAT)
707 vmesa->regCmdA_End |= HC_HShading_FlatB;
708 break;
709 case GL_TRIANGLE_FAN:
710 vmesa->regCmdA_End = vmesa->regCmdA | HC_HPMType_Tri | HC_HVCycle_AFP |
711 HC_HVCycle_AA | HC_HVCycle_BC | HC_HVCycle_NewC;
712 regCmdB |= HC_HVCycle_AA | HC_HVCycle_BC | HC_HVCycle_NewC;
713 if (ctx->Light.ShadeModel == GL_FLAT)
714 vmesa->regCmdA_End |= HC_HShading_FlatC;
715 break;
716 case GL_QUADS:
717 abort();
718 return;
719 case GL_QUAD_STRIP:
720 abort();
721 return;
722 case GL_POLYGON:
723 vmesa->regCmdA_End = vmesa->regCmdA | HC_HPMType_Tri | HC_HVCycle_AFP |
724 HC_HVCycle_AA | HC_HVCycle_BC | HC_HVCycle_NewC;
725 regCmdB |= HC_HVCycle_AA | HC_HVCycle_BC | HC_HVCycle_NewC;
726 if (ctx->Light.ShadeModel == GL_FLAT)
727 vmesa->regCmdA_End |= HC_HShading_FlatC;
728 break;
729 default:
730 abort();
731 return;
732 }
733
734 assert((vmesa->dmaLow & 0x4) == 0);
735
736 BEGIN_RING(8);
737 OUT_RING( HC_HEADER2 );
738 OUT_RING( (HC_ParaType_NotTex << 16) );
739 OUT_RING( 0xCCCCCCCC );
740 OUT_RING( 0xDDDDDDDD );
741
742 OUT_RING( HC_HEADER2 );
743 OUT_RING( (HC_ParaType_CmdVdata << 16) );
744 OUT_RING( regCmdB );
745 OUT_RING( vmesa->regCmdA_End );
746 ADVANCE_RING();
747
748 vmesa->dmaLastPrim = vmesa->dmaLow;
749 vmesa->hwPrimitive = hwprim;
750 }
751
752 /* Callback for mesa:
753 */
754 static void viaRenderPrimitive( GLcontext *ctx, GLuint prim )
755 {
756 viaRasterPrimitive( ctx, prim, hwPrim[prim] );
757 }
758
759
760 void viaFinishPrimitive(viaContextPtr vmesa)
761 {
762 if (!vmesa->dmaLastPrim) {
763 return;
764 }
765 else if (vmesa->dmaLow != vmesa->dmaLastPrim) {
766 GLuint cmdA = vmesa->regCmdA_End | HC_HPLEND_MASK | HC_HPMValidN_MASK | HC_HE3Fire_MASK;
767 RING_VARS;
768
769 /* KW: modified 0x1 to 0x4 below:
770 */
771 if ((vmesa->dmaLow & 0x1) || !vmesa->useAgp) {
772 BEGIN_RING_NOCHECK( 1 );
773 OUT_RING( cmdA );
774 ADVANCE_RING();
775 }
776 else {
777 BEGIN_RING_NOCHECK( 2 );
778 OUT_RING( cmdA );
779 OUT_RING( cmdA );
780 ADVANCE_RING();
781 }
782 vmesa->dmaLastPrim = 0;
783
784 if (1 || vmesa->dmaLow > VIA_DMA_HIGHWATER)
785 viaFlushPrims( vmesa );
786 }
787 else {
788 assert(vmesa->dmaLow >= (32 + DMA_OFFSET));
789 vmesa->dmaLow -= 32;
790 vmesa->dmaLastPrim = 0;
791 }
792 }
793
794
795 /**********************************************************************/
796 /* Transition to/from hardware rasterization. */
797 /**********************************************************************/
798
799
800 void viaFallback(viaContextPtr vmesa, GLuint bit, GLboolean mode)
801 {
802 GLcontext *ctx = vmesa->glCtx;
803 TNLcontext *tnl = TNL_CONTEXT(ctx);
804 GLuint oldfallback = vmesa->Fallback;
805 if (VIA_DEBUG) fprintf(stderr, "%s old %x bit %x mode %d\n", __FUNCTION__,
806 vmesa->Fallback, bit, mode);
807
808 if (mode) {
809 vmesa->Fallback |= bit;
810 if (oldfallback == 0) {
811 if (VIA_DEBUG) fprintf(stderr, "ENTER FALLBACK\n");
812 VIA_FLUSH_DMA(vmesa);
813 _swsetup_Wakeup(ctx);
814 vmesa->renderIndex = ~0;
815 }
816 }
817 else {
818 vmesa->Fallback &= ~bit;
819 if (oldfallback == bit) {
820 if (VIA_DEBUG) fprintf(stderr, "LEAVE FALLBACK\n");
821 tnl->Driver.Render.Start = viaRenderStart;
822 tnl->Driver.Render.PrimitiveNotify = viaRenderPrimitive;
823 tnl->Driver.Render.Finish = viaRenderFinish;
824 tnl->Driver.Render.BuildVertices = viaBuildVertices;
825 vmesa->newState |= (_VIA_NEW_RENDERSTATE|_VIA_NEW_VERTEX);
826 }
827 }
828
829 }
830
831
832 /**********************************************************************/
833 /* Initialization. */
834 /**********************************************************************/
835
836
837 void viaInitTriFuncs(GLcontext *ctx)
838 {
839 TNLcontext *tnl = TNL_CONTEXT(ctx);
840 static int firsttime = 1;
841
842 if (firsttime) {
843 init_rast_tab();
844 firsttime = 0;
845 }
846
847 tnl->Driver.RunPipeline = viaRunPipeline;
848 tnl->Driver.Render.Start = viaRenderStart;
849 tnl->Driver.Render.Finish = viaRenderFinish;
850 tnl->Driver.Render.PrimitiveNotify = viaRenderPrimitive;
851 tnl->Driver.Render.ResetLineStipple = _swrast_ResetLineStipple;
852 tnl->Driver.Render.BuildVertices = viaBuildVertices;
853 }