2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 * This file contains "accelerated" triangle functions. It should be
28 * fairly easy to write new special-purpose triangle functions and hook
29 * them into this module.
33 #include "main/depth.h"
34 #include "main/macros.h"
35 #include "main/imports.h"
36 #include "main/mtypes.h"
37 #include "glxheader.h"
40 /* Internal swrast includes:
42 #include "swrast/s_context.h"
43 #include "swrast/s_depth.h"
44 #include "swrast/s_triangle.h"
47 #define GET_XRB(XRB) struct xmesa_renderbuffer *XRB = \
48 xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0]->Wrapped)
51 /**********************************************************************/
52 /*** Triangle rendering ***/
53 /**********************************************************************/
59 * XImage, smooth, depth-buffered, PF_TRUECOLOR triangle.
61 #define NAME smooth_TRUECOLOR_z_triangle
63 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
66 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
69 #define RENDER_SPAN( span ) { \
70 GLint x = span.x, y = YFLIP(xrb, span.y); \
72 for (i = 0; i < span.end; i++, x++) { \
73 const DEPTH_TYPE z = FixedToDepth(span.z); \
76 PACK_TRUECOLOR(p, FixedToInt(span.red), \
77 FixedToInt(span.green), FixedToInt(span.blue)); \
78 XMesaPutPixel(xrb->ximage, x, y, p); \
81 span.red += span.redStep; \
82 span.green += span.greenStep; \
83 span.blue += span.blueStep; \
84 span.z += span.zStep; \
87 #include "swrast/s_tritemp.h"
93 * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle.
95 #define NAME smooth_8A8B8G8R_z_triangle
97 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
99 #define INTERP_ALPHA 1
100 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
101 #define PIXEL_TYPE GLuint
102 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
105 #define RENDER_SPAN( span ) { \
107 for (i = 0; i < span.end; i++) { \
108 const DEPTH_TYPE z = FixedToDepth(span.z); \
110 pRow[i] = PACK_8A8B8G8R(FixedToInt(span.red), \
111 FixedToInt(span.green), FixedToInt(span.blue), \
112 FixedToInt(span.alpha)); \
115 span.red += span.redStep; \
116 span.green += span.greenStep; \
117 span.blue += span.blueStep; \
118 span.alpha += span.alphaStep; \
119 span.z += span.zStep; \
122 #include "swrast/s_tritemp.h"
127 * XImage, smooth, depth-buffered, PF_8A8R8G8B triangle.
129 #define NAME smooth_8A8R8G8B_z_triangle
131 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
133 #define INTERP_ALPHA 1
134 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
135 #define PIXEL_TYPE GLuint
136 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
140 #define RENDER_SPAN( span ) { \
142 for (i = 0; i < span.end; i++) { \
143 const DEPTH_TYPE z = FixedToDepth(span.z); \
145 pRow[i] = PACK_8A8R8G8B(FixedToInt(span.red), \
146 FixedToInt(span.green), FixedToInt(span.blue), \
147 FixedToInt(span.alpha)); \
150 span.red += span.redStep; \
151 span.green += span.greenStep; \
152 span.blue += span.blueStep; \
153 span.alpha += span.alphaStep; \
154 span.z += span.zStep; \
157 #include "swrast/s_tritemp.h"
162 * XImage, smooth, depth-buffered, PF_8R8G8B triangle.
164 #define NAME smooth_8R8G8B_z_triangle
166 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
168 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
169 #define PIXEL_TYPE GLuint
170 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
174 #define RENDER_SPAN( span ) { \
176 for (i = 0; i < span.end; i++) { \
177 const DEPTH_TYPE z = FixedToDepth(span.z); \
179 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
180 FixedToInt(span.green), FixedToInt(span.blue)); \
183 span.red += span.redStep; \
184 span.green += span.greenStep; \
185 span.blue += span.blueStep; \
186 span.z += span.zStep; \
189 #include "swrast/s_tritemp.h"
194 * XImage, smooth, depth-buffered, PF_8R8G8B24 triangle.
196 #define NAME smooth_8R8G8B24_z_triangle
198 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
200 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
201 #define PIXEL_TYPE bgr_t
202 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
205 #define RENDER_SPAN( span ) { \
207 for (i = 0; i < span.end; i++) { \
208 const DEPTH_TYPE z = FixedToDepth(span.z); \
210 PIXEL_TYPE *ptr = pRow + i; \
211 ptr->r = FixedToInt(span.red); \
212 ptr->g = FixedToInt(span.green); \
213 ptr->b = FixedToInt(span.blue); \
216 span.red += span.redStep; \
217 span.green += span.greenStep; \
218 span.blue += span.blueStep; \
219 span.z += span.zStep; \
221 #include "swrast/s_tritemp.h"
226 * XImage, smooth, depth-buffered, PF_TRUEDITHER triangle.
228 #define NAME smooth_TRUEDITHER_z_triangle
230 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
233 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
235 #define RENDER_SPAN( span ) { \
237 GLint x = span.x, y = YFLIP(xrb, span.y); \
238 for (i = 0; i < span.end; i++, x++) { \
239 const DEPTH_TYPE z = FixedToDepth(span.z); \
242 PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \
243 FixedToInt(span.green), FixedToInt(span.blue)); \
244 XMesaPutPixel(xrb->ximage, x, y, p); \
247 span.red += span.redStep; \
248 span.green += span.greenStep; \
249 span.blue += span.blueStep; \
250 span.z += span.zStep; \
252 #include "swrast/s_tritemp.h"
257 * XImage, smooth, depth-buffered, PF_5R6G5B triangle.
259 #define NAME smooth_5R6G5B_z_triangle
261 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
263 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
264 #define PIXEL_TYPE GLushort
265 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
268 #define RENDER_SPAN( span ) { \
270 for (i = 0; i < span.end; i++) { \
271 const DEPTH_TYPE z = FixedToDepth(span.z); \
273 pRow[i] = PACK_5R6G5B(FixedToInt(span.red), \
274 FixedToInt(span.green), FixedToInt(span.blue)); \
277 span.red += span.redStep; \
278 span.green += span.greenStep; \
279 span.blue += span.blueStep; \
280 span.z += span.zStep; \
282 #include "swrast/s_tritemp.h"
287 * XImage, smooth, depth-buffered, PF_DITHER_5R6G5B triangle.
289 #define NAME smooth_DITHER_5R6G5B_z_triangle
291 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
293 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
294 #define PIXEL_TYPE GLushort
295 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
297 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
299 #define RENDER_SPAN( span ) { \
301 GLint x = span.x, y = YFLIP(xrb, span.y); \
302 for (i = 0; i < span.end; i++, x++) { \
303 const DEPTH_TYPE z = FixedToDepth(span.z); \
305 PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \
306 FixedToInt(span.green), FixedToInt(span.blue)); \
309 span.red += span.redStep; \
310 span.green += span.greenStep; \
311 span.blue += span.blueStep; \
312 span.z += span.zStep; \
314 #include "swrast/s_tritemp.h"
319 * XImage, smooth, depth-buffered, 8-bit, PF_DITHER8 triangle.
321 #define NAME smooth_DITHER8_z_triangle
323 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
325 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
326 #define PIXEL_TYPE GLubyte
327 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
330 #define RENDER_SPAN( span ) { \
332 GLint x = span.x, y = YFLIP(xrb, span.y); \
334 for (i = 0; i < span.end; i++, x++) { \
335 const DEPTH_TYPE z = FixedToDepth(span.z); \
337 pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red),\
338 FixedToInt(span.green), FixedToInt(span.blue) ); \
341 span.red += span.redStep; \
342 span.green += span.greenStep; \
343 span.blue += span.blueStep; \
344 span.z += span.zStep; \
346 #include "swrast/s_tritemp.h"
351 * XImage, smooth, depth-buffered, PF_DITHER triangle.
353 #define NAME smooth_DITHER_z_triangle
355 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
359 XMesaImage *img = xrb->ximage;
360 #define RENDER_SPAN( span ) { \
362 GLint x = span.x, y = YFLIP(xrb, span.y); \
364 for (i = 0; i < span.end; i++, x++) { \
365 const DEPTH_TYPE z = FixedToDepth(span.z); \
367 unsigned long p = XDITHER(x, FixedToInt(span.red), \
368 FixedToInt(span.green), FixedToInt(span.blue)); \
369 XMesaPutPixel(img, x, y, p); \
372 span.red += span.redStep; \
373 span.green += span.greenStep; \
374 span.blue += span.blueStep; \
375 span.z += span.zStep; \
377 #include "swrast/s_tritemp.h"
382 * XImage, smooth, depth-buffered, 8-bit PF_LOOKUP triangle.
384 #define NAME smooth_LOOKUP8_z_triangle
386 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
388 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
389 #define PIXEL_TYPE GLubyte
390 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
393 #define RENDER_SPAN( span ) { \
396 for (i = 0; i < span.end; i++) { \
397 const DEPTH_TYPE z = FixedToDepth(span.z); \
399 pRow[i] = LOOKUP(FixedToInt(span.red), \
400 FixedToInt(span.green), FixedToInt(span.blue)); \
403 span.red += span.redStep; \
404 span.green += span.greenStep; \
405 span.blue += span.blueStep; \
406 span.z += span.zStep; \
408 #include "swrast/s_tritemp.h"
413 * XImage, smooth, depth-buffered, 8-bit PF_HPCR triangle.
415 #define NAME smooth_HPCR_z_triangle
417 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
419 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
420 #define PIXEL_TYPE GLubyte
421 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
423 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
425 #define RENDER_SPAN( span ) { \
427 GLint x = span.x, y = YFLIP(xrb, span.y); \
428 for (i = 0; i < span.end; i++, x++) { \
429 const DEPTH_TYPE z = FixedToDepth(span.z); \
431 pRow[i] = DITHER_HPCR(x, y, FixedToInt(span.red), \
432 FixedToInt(span.green), FixedToInt(span.blue) ); \
435 span.red += span.redStep; \
436 span.green += span.greenStep; \
437 span.blue += span.blueStep; \
438 span.z += span.zStep; \
440 #include "swrast/s_tritemp.h"
445 * XImage, flat, depth-buffered, PF_TRUECOLOR triangle.
447 #define NAME flat_TRUECOLOR_z_triangle
449 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
451 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
453 XMesaImage *img = xrb->ximage; \
454 unsigned long pixel; \
455 PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]);
456 #define RENDER_SPAN( span ) { \
458 GLint x = span.x, y = YFLIP(xrb, span.y); \
459 for (i = 0; i < span.end; i++, x++) { \
460 const DEPTH_TYPE z = FixedToDepth(span.z); \
462 XMesaPutPixel(img, x, y, pixel); \
465 span.z += span.zStep; \
467 #include "swrast/s_tritemp.h"
472 * XImage, flat, depth-buffered, PF_8A8B8G8R triangle.
474 #define NAME flat_8A8B8G8R_z_triangle
476 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
477 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
478 #define PIXEL_TYPE GLuint
479 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
482 GLuint p = PACK_8A8B8G8R( v2->color[0], v2->color[1],\
483 v2->color[2], v2->color[3]);
484 #define RENDER_SPAN( span ) { \
486 for (i = 0; i < span.end; i++) { \
487 const DEPTH_TYPE z = FixedToDepth(span.z); \
489 pRow[i] = (PIXEL_TYPE) p; \
492 span.z += span.zStep; \
494 #include "swrast/s_tritemp.h"
499 * XImage, flat, depth-buffered, PF_8A8R8G8B triangle.
501 #define NAME flat_8A8R8G8B_z_triangle
503 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
504 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
505 #define PIXEL_TYPE GLuint
506 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
509 GLuint p = PACK_8A8R8G8B(v2->color[0], v2->color[1], \
510 v2->color[2], v2->color[3]);
511 #define RENDER_SPAN( span ) { \
513 for (i = 0; i < span.end; i++) { \
514 const DEPTH_TYPE z = FixedToDepth(span.z); \
516 pRow[i] = (PIXEL_TYPE) p; \
519 span.z += span.zStep; \
521 #include "swrast/s_tritemp.h"
526 * XImage, flat, depth-buffered, PF_8R8G8B triangle.
528 #define NAME flat_8R8G8B_z_triangle
530 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
531 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
532 #define PIXEL_TYPE GLuint
533 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
536 GLuint p = PACK_8R8G8B( v2->color[0], v2->color[1], v2->color[2] );
537 #define RENDER_SPAN( span ) { \
539 for (i = 0; i < span.end; i++) { \
540 DEPTH_TYPE z = FixedToDepth(span.z); \
542 pRow[i] = (PIXEL_TYPE) p; \
545 span.z += span.zStep; \
548 #include "swrast/s_tritemp.h"
553 * XImage, flat, depth-buffered, PF_8R8G8B24 triangle.
555 #define NAME flat_8R8G8B24_z_triangle
557 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
558 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
559 #define PIXEL_TYPE bgr_t
560 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
563 const GLubyte *color = v2->color;
564 #define RENDER_SPAN( span ) { \
566 for (i = 0; i < span.end; i++) { \
567 const DEPTH_TYPE z = FixedToDepth(span.z); \
569 PIXEL_TYPE *ptr = pRow + i; \
570 ptr->r = color[RCOMP]; \
571 ptr->g = color[GCOMP]; \
572 ptr->b = color[BCOMP]; \
575 span.z += span.zStep; \
577 #include "swrast/s_tritemp.h"
582 * XImage, flat, depth-buffered, PF_TRUEDITHER triangle.
584 #define NAME flat_TRUEDITHER_z_triangle
586 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
588 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
590 XMesaImage *img = xrb->ximage;
591 #define RENDER_SPAN( span ) { \
593 GLint x = span.x, y = YFLIP(xrb, span.y); \
594 for (i = 0; i < span.end; i++, x++) { \
595 const DEPTH_TYPE z = FixedToDepth(span.z); \
598 PACK_TRUEDITHER(p, x, y, v2->color[0], \
599 v2->color[1], v2->color[2]); \
600 XMesaPutPixel(img, x, y, p); \
603 span.z += span.zStep; \
605 #include "swrast/s_tritemp.h"
610 * XImage, flat, depth-buffered, PF_5R6G5B triangle.
612 #define NAME flat_5R6G5B_z_triangle
614 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
615 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
616 #define PIXEL_TYPE GLushort
617 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
620 GLushort p = PACK_5R6G5B( v2->color[0], v2->color[1], v2->color[2] );
621 #define RENDER_SPAN( span ) { \
623 for (i = 0; i < span.end; i++) { \
624 const DEPTH_TYPE z = FixedToDepth(span.z); \
626 pRow[i] = (PIXEL_TYPE) p; \
629 span.z += span.zStep; \
631 #include "swrast/s_tritemp.h"
636 * XImage, flat, depth-buffered, PF_DITHER_5R6G5B triangle.
638 #define NAME flat_DITHER_5R6G5B_z_triangle
640 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
641 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
642 #define PIXEL_TYPE GLushort
643 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
645 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
647 const GLubyte *color = v2->color;
648 #define RENDER_SPAN( span ) { \
650 GLint x = span.x, y = YFLIP(xrb, span.y); \
651 for (i = 0; i < span.end; i++, x++) { \
652 const DEPTH_TYPE z = FixedToDepth(span.z); \
654 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \
655 color[GCOMP], color[BCOMP]); \
658 span.z += span.zStep; \
660 #include "swrast/s_tritemp.h"
665 * XImage, flat, depth-buffered, 8-bit PF_DITHER triangle.
667 #define NAME flat_DITHER8_z_triangle
669 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
670 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
671 #define PIXEL_TYPE GLubyte
672 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
675 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
676 #define RENDER_SPAN( span ) { \
678 GLint x = span.x, y = YFLIP(xrb, span.y); \
679 FLAT_DITHER_ROW_SETUP(YFLIP(xrb, y)); \
680 for (i = 0; i < span.end; i++, x++) { \
681 const DEPTH_TYPE z = FixedToDepth(span.z); \
683 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x); \
686 span.z += span.zStep; \
688 #include "swrast/s_tritemp.h"
693 * XImage, flat, depth-buffered, PF_DITHER triangle.
695 #define NAME flat_DITHER_z_triangle
697 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
700 XMesaImage *img = xrb->ximage; \
701 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
702 #define RENDER_SPAN( span ) { \
704 GLint x = span.x, y = YFLIP(xrb, span.y); \
705 FLAT_DITHER_ROW_SETUP(y); \
706 for (i = 0; i < span.end; i++, x++) { \
707 const DEPTH_TYPE z = FixedToDepth(span.z); \
709 unsigned long p = FLAT_DITHER(x); \
710 XMesaPutPixel(img, x, y, p); \
713 span.z += span.zStep; \
715 #include "swrast/s_tritemp.h"
720 * XImage, flat, depth-buffered, 8-bit PF_HPCR triangle.
722 #define NAME flat_HPCR_z_triangle
724 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
725 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
726 #define PIXEL_TYPE GLubyte
727 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
729 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
731 GLubyte r = v2->color[0]; \
732 GLubyte g = v2->color[1]; \
733 GLubyte b = v2->color[2];
734 #define RENDER_SPAN( span ) { \
736 GLint x = span.x, y = YFLIP(xrb, span.y); \
737 for (i = 0; i < span.end; i++, x++) { \
738 const DEPTH_TYPE z = FixedToDepth(span.z); \
740 pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b); \
743 span.z += span.zStep; \
745 #include "swrast/s_tritemp.h"
750 * XImage, flat, depth-buffered, 8-bit PF_LOOKUP triangle.
752 #define NAME flat_LOOKUP8_z_triangle
754 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
755 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
756 #define PIXEL_TYPE GLubyte
757 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
761 GLubyte r = v2->color[0]; \
762 GLubyte g = v2->color[1]; \
763 GLubyte b = v2->color[2]; \
764 GLubyte p = LOOKUP(r,g,b);
765 #define RENDER_SPAN( span ) { \
767 for (i = 0; i < span.end; i++) { \
768 const DEPTH_TYPE z = FixedToDepth(span.z); \
773 span.z += span.zStep; \
775 #include "swrast/s_tritemp.h"
780 * XImage, smooth, NON-depth-buffered, PF_TRUECOLOR triangle.
782 #define NAME smooth_TRUECOLOR_triangle
785 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
787 XMesaImage *img = xrb->ximage;
788 #define RENDER_SPAN( span ) { \
790 GLint x = span.x, y = YFLIP(xrb, span.y); \
791 for (i = 0; i < span.end; i++, x++) { \
793 PACK_TRUECOLOR(p, FixedToInt(span.red), \
794 FixedToInt(span.green), FixedToInt(span.blue)); \
795 XMesaPutPixel(img, x, y, p); \
796 span.red += span.redStep; \
797 span.green += span.greenStep; \
798 span.blue += span.blueStep; \
800 #include "swrast/s_tritemp.h"
805 * XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle.
807 #define NAME smooth_8A8B8G8R_triangle
809 #define INTERP_ALPHA 1
810 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
811 #define PIXEL_TYPE GLuint
812 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
815 #define RENDER_SPAN( span ) { \
817 for (i = 0; i < span.end; i++) { \
818 pRow[i] = PACK_8A8B8G8R(FixedToInt(span.red), \
819 FixedToInt(span.green), FixedToInt(span.blue), \
820 FixedToInt(span.alpha)); \
821 span.red += span.redStep; \
822 span.green += span.greenStep; \
823 span.blue += span.blueStep; \
824 span.alpha += span.alphaStep; \
826 #include "swrast/s_tritemp.h"
831 * XImage, smooth, NON-depth-buffered, PF_8A8R8G8B triangle.
833 #define NAME smooth_8A8R8G8B_triangle
835 #define INTERP_ALPHA 1
836 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
837 #define PIXEL_TYPE GLuint
838 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
841 #define RENDER_SPAN( span ) { \
843 for (i = 0; i < span.end; i++) { \
844 pRow[i] = PACK_8A8R8G8B(FixedToInt(span.red), \
845 FixedToInt(span.green), FixedToInt(span.blue), \
846 FixedToInt(span.alpha)); \
847 span.red += span.redStep; \
848 span.green += span.greenStep; \
849 span.blue += span.blueStep; \
850 span.alpha += span.alphaStep; \
852 #include "swrast/s_tritemp.h"
857 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
859 #define NAME smooth_8R8G8B_triangle
861 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
862 #define PIXEL_TYPE GLuint
863 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
866 #define RENDER_SPAN( span ) { \
868 for (i = 0; i < span.end; i++) { \
869 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
870 FixedToInt(span.green), FixedToInt(span.blue) ); \
871 span.red += span.redStep; \
872 span.green += span.greenStep; \
873 span.blue += span.blueStep; \
875 #include "swrast/s_tritemp.h"
880 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
882 #define NAME smooth_8R8G8B24_triangle
884 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
885 #define PIXEL_TYPE bgr_t
886 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
889 #define RENDER_SPAN( span ) { \
891 PIXEL_TYPE *pixel = pRow; \
892 for (i = 0; i < span.end; i++, pixel++) { \
893 pixel->r = FixedToInt(span.red); \
894 pixel->g = FixedToInt(span.green); \
895 pixel->b = FixedToInt(span.blue); \
896 span.red += span.redStep; \
897 span.green += span.greenStep; \
898 span.blue += span.blueStep; \
900 #include "swrast/s_tritemp.h"
905 * XImage, smooth, NON-depth-buffered, PF_TRUEDITHER triangle.
907 #define NAME smooth_TRUEDITHER_triangle
910 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
912 XMesaImage *img = xrb->ximage;
913 #define RENDER_SPAN( span ) { \
915 GLint x = span.x, y = YFLIP(xrb, span.y); \
916 for (i = 0; i < span.end; i++, x++) { \
918 PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \
919 FixedToInt(span.green), FixedToInt(span.blue)); \
920 XMesaPutPixel(img, x, y, p ); \
921 span.red += span.redStep; \
922 span.green += span.greenStep; \
923 span.blue += span.blueStep; \
925 #include "swrast/s_tritemp.h"
930 * XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle.
932 #define NAME smooth_5R6G5B_triangle
934 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
935 #define PIXEL_TYPE GLushort
936 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
939 #define RENDER_SPAN( span ) { \
941 for (i = 0; i < span.end; i++) { \
942 pRow[i] = (PIXEL_TYPE) PACK_5R6G5B(FixedToInt(span.red), \
943 FixedToInt(span.green), FixedToInt(span.blue)); \
944 span.red += span.redStep; \
945 span.green += span.greenStep; \
946 span.blue += span.blueStep; \
948 #include "swrast/s_tritemp.h"
953 * XImage, smooth, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
955 #define NAME smooth_DITHER_5R6G5B_triangle
957 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
958 #define PIXEL_TYPE GLushort
959 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
961 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
963 #define RENDER_SPAN( span ) { \
965 GLint x = span.x, y = YFLIP(xrb, span.y); \
966 for (i = 0; i < span.end; i++, x++) { \
967 PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \
968 FixedToInt(span.green), FixedToInt(span.blue)); \
969 span.red += span.redStep; \
970 span.green += span.greenStep; \
971 span.blue += span.blueStep; \
973 #include "swrast/s_tritemp.h"
978 * XImage, smooth, NON-depth-buffered, 8-bit PF_DITHER triangle.
980 #define NAME smooth_DITHER8_triangle
982 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
983 #define PIXEL_TYPE GLubyte
984 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
987 #define RENDER_SPAN( span ) { \
989 GLint x = span.x, y = YFLIP(xrb, span.y); \
991 for (i = 0; i < span.end; i++, x++) { \
992 pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red), \
993 FixedToInt(span.green), FixedToInt(span.blue) ); \
994 span.red += span.redStep; \
995 span.green += span.greenStep; \
996 span.blue += span.blueStep; \
998 #include "swrast/s_tritemp.h"
1003 * XImage, smooth, NON-depth-buffered, PF_DITHER triangle.
1005 #define NAME smooth_DITHER_triangle
1006 #define INTERP_RGB 1
1007 #define SETUP_CODE \
1009 XMesaImage *img = xrb->ximage;
1010 #define RENDER_SPAN( span ) { \
1012 GLint x = span.x, y = YFLIP(xrb, span.y); \
1014 for (i = 0; i < span.end; i++, x++) { \
1015 unsigned long p = XDITHER(x, FixedToInt(span.red), \
1016 FixedToInt(span.green), FixedToInt(span.blue) ); \
1017 XMesaPutPixel(img, x, y, p); \
1018 span.red += span.redStep; \
1019 span.green += span.greenStep; \
1020 span.blue += span.blueStep; \
1022 #include "swrast/s_tritemp.h"
1027 * XImage, smooth, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
1029 #define NAME smooth_LOOKUP8_triangle
1030 #define INTERP_RGB 1
1031 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
1032 #define PIXEL_TYPE GLubyte
1033 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1034 #define SETUP_CODE \
1036 #define RENDER_SPAN( span ) { \
1039 for (i = 0; i < span.end; i++) { \
1040 pRow[i] = LOOKUP(FixedToInt(span.red), \
1041 FixedToInt(span.green), FixedToInt(span.blue)); \
1042 span.red += span.redStep; \
1043 span.green += span.greenStep; \
1044 span.blue += span.blueStep; \
1046 #include "swrast/s_tritemp.h"
1051 * XImage, smooth, NON-depth-buffered, 8-bit PF_HPCR triangle.
1053 #define NAME smooth_HPCR_triangle
1054 #define INTERP_RGB 1
1055 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
1056 #define PIXEL_TYPE GLubyte
1057 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1058 #define SETUP_CODE \
1059 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1061 #define RENDER_SPAN( span ) { \
1063 GLint x = span.x, y = YFLIP(xrb, span.y); \
1064 for (i = 0; i < span.end; i++, x++) { \
1065 pRow[i] = DITHER_HPCR(x, y, FixedToInt(span.red), \
1066 FixedToInt(span.green), FixedToInt(span.blue)); \
1067 span.red += span.redStep; \
1068 span.green += span.greenStep; \
1069 span.blue += span.blueStep; \
1071 #include "swrast/s_tritemp.h"
1076 * XImage, flat, NON-depth-buffered, PF_TRUECOLOR triangle.
1078 #define NAME flat_TRUECOLOR_triangle
1079 #define SETUP_CODE \
1080 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1082 XMesaImage *img = xrb->ximage; \
1083 unsigned long pixel; \
1084 PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]);
1085 #define RENDER_SPAN( span ) { \
1087 GLint x = span.x, y = YFLIP(xrb, span.y); \
1088 for (i = 0; i < span.end; i++, x++) { \
1089 XMesaPutPixel(img, x, y, pixel); \
1091 #include "swrast/s_tritemp.h"
1096 * XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle.
1098 #define NAME flat_8A8B8G8R_triangle
1099 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
1100 #define PIXEL_TYPE GLuint
1101 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1102 #define SETUP_CODE \
1104 unsigned long p = PACK_8B8G8R( v2->color[0], \
1105 v2->color[1], v2->color[2] );
1106 #define RENDER_SPAN( span ) { \
1108 for (i = 0; i < span.end; i++) { \
1109 pRow[i] = (PIXEL_TYPE) p; \
1111 #include "swrast/s_tritemp.h"
1116 * XImage, flat, NON-depth-buffered, PF_8A8R8G8B triangle.
1118 #define NAME flat_8A8R8G8B_triangle
1119 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
1120 #define PIXEL_TYPE GLuint
1121 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1122 #define SETUP_CODE \
1124 unsigned long p = PACK_8R8G8B( v2->color[0], \
1125 v2->color[1], v2->color[2] );
1126 #define RENDER_SPAN( span ) { \
1128 for (i = 0; i < span.end; i++) { \
1129 pRow[i] = (PIXEL_TYPE) p; \
1131 #include "swrast/s_tritemp.h"
1136 * XImage, flat, NON-depth-buffered, PF_8R8G8B triangle.
1138 #define NAME flat_8R8G8B_triangle
1139 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
1140 #define PIXEL_TYPE GLuint
1141 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1142 #define SETUP_CODE \
1144 unsigned long p = PACK_8R8G8B( v2->color[0], \
1145 v2->color[1], v2->color[2] );
1146 #define RENDER_SPAN( span ) { \
1148 for (i = 0; i < span.end; i++) { \
1149 pRow[i] = (PIXEL_TYPE) p; \
1151 #include "swrast/s_tritemp.h"
1156 * XImage, flat, NON-depth-buffered, PF_8R8G8B24 triangle.
1158 #define NAME flat_8R8G8B24_triangle
1159 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
1160 #define PIXEL_TYPE bgr_t
1161 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1162 #define SETUP_CODE \
1164 const GLubyte *color = v2->color;
1165 #define RENDER_SPAN( span ) { \
1167 PIXEL_TYPE *pixel = pRow; \
1168 for (i = 0; i < span.end; i++, pixel++) { \
1169 pixel->r = color[RCOMP]; \
1170 pixel->g = color[GCOMP]; \
1171 pixel->b = color[BCOMP]; \
1173 #include "swrast/s_tritemp.h"
1178 * XImage, flat, NON-depth-buffered, PF_TRUEDITHER triangle.
1180 #define NAME flat_TRUEDITHER_triangle
1181 #define SETUP_CODE \
1182 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1184 XMesaImage *img = xrb->ximage;
1185 #define RENDER_SPAN( span ) { \
1187 GLint x = span.x, y = YFLIP(xrb, span.y); \
1188 for (i = 0; i < span.end; i++, x++) { \
1190 PACK_TRUEDITHER(p, x, y, v2->color[0], \
1191 v2->color[1], v2->color[2] ); \
1192 XMesaPutPixel(img, x, y, p); \
1194 #include "swrast/s_tritemp.h"
1199 * XImage, flat, NON-depth-buffered, PF_5R6G5B triangle.
1201 #define NAME flat_5R6G5B_triangle
1202 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
1203 #define PIXEL_TYPE GLushort
1204 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1205 #define SETUP_CODE \
1207 unsigned long p = PACK_5R6G5B( v2->color[0], \
1208 v2->color[1], v2->color[2] );
1209 #define RENDER_SPAN( span ) { \
1211 for (i = 0; i < span.end; i++) { \
1212 pRow[i] = (PIXEL_TYPE) p; \
1214 #include "swrast/s_tritemp.h"
1219 * XImage, flat, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
1221 #define NAME flat_DITHER_5R6G5B_triangle
1222 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
1223 #define PIXEL_TYPE GLushort
1224 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1225 #define SETUP_CODE \
1226 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1228 const GLubyte *color = v2->color;
1229 #define RENDER_SPAN( span ) { \
1231 GLint x = span.x, y = YFLIP(xrb, span.y); \
1232 for (i = 0; i < span.end; i++, x++) { \
1233 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \
1234 color[GCOMP], color[BCOMP]); \
1236 #include "swrast/s_tritemp.h"
1241 * XImage, flat, NON-depth-buffered, 8-bit PF_DITHER triangle.
1243 #define NAME flat_DITHER8_triangle
1244 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
1245 #define PIXEL_TYPE GLubyte
1246 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1247 #define SETUP_CODE \
1249 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
1250 #define RENDER_SPAN( span ) { \
1252 GLint x = span.x, y = YFLIP(xrb, span.y); \
1253 FLAT_DITHER_ROW_SETUP(YFLIP(xrb, y)); \
1254 for (i = 0; i < span.end; i++, x++) { \
1255 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x); \
1257 #include "swrast/s_tritemp.h"
1262 * XImage, flat, NON-depth-buffered, PF_DITHER triangle.
1264 #define NAME flat_DITHER_triangle
1265 #define SETUP_CODE \
1267 XMesaImage *img = xrb->ximage; \
1268 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
1269 #define RENDER_SPAN( span ) { \
1271 GLint x = span.x, y = YFLIP(xrb, span.y); \
1272 FLAT_DITHER_ROW_SETUP(y); \
1273 for (i = 0; i < span.end; i++, x++) { \
1274 unsigned long p = FLAT_DITHER(x); \
1275 XMesaPutPixel(img, x, y, p ); \
1277 #include "swrast/s_tritemp.h"
1282 * XImage, flat, NON-depth-buffered, 8-bit PF_HPCR triangle.
1284 #define NAME flat_HPCR_triangle
1285 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
1286 #define PIXEL_TYPE GLubyte
1287 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1288 #define SETUP_CODE \
1289 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1291 GLubyte r = v2->color[0]; \
1292 GLubyte g = v2->color[1]; \
1293 GLubyte b = v2->color[2];
1294 #define RENDER_SPAN( span ) { \
1296 GLint x = span.x, y = YFLIP(xrb, span.y); \
1297 for (i = 0; i < span.end; i++, x++) { \
1298 pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b); \
1300 #include "swrast/s_tritemp.h"
1305 * XImage, flat, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
1307 #define NAME flat_LOOKUP8_triangle
1308 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
1309 #define PIXEL_TYPE GLubyte
1310 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1311 #define SETUP_CODE \
1314 GLubyte r = v2->color[0]; \
1315 GLubyte g = v2->color[1]; \
1316 GLubyte b = v2->color[2]; \
1317 GLubyte p = LOOKUP(r,g,b);
1318 #define RENDER_SPAN( span ) { \
1320 for (i = 0; i < span.end; i++) { \
1321 pRow[i] = (PIXEL_TYPE) p; \
1323 #include "swrast/s_tritemp.h"
1326 #endif /* CHAN_BITS == 8 */
1329 #if defined(DEBUG) && CHAN_BITS == 8
1330 extern void _xmesa_print_triangle_func( swrast_tri_func triFunc
);
1331 void _xmesa_print_triangle_func( swrast_tri_func triFunc
)
1333 _mesa_printf("XMesa tri func = ");
1334 if (triFunc
==smooth_TRUECOLOR_z_triangle
)
1335 _mesa_printf("smooth_TRUECOLOR_z_triangle\n");
1336 else if (triFunc
==smooth_8A8B8G8R_z_triangle
)
1337 _mesa_printf("smooth_8A8B8G8R_z_triangle\n");
1338 else if (triFunc
==smooth_8A8R8G8B_z_triangle
)
1339 _mesa_printf("smooth_8A8R8G8B_z_triangle\n");
1340 else if (triFunc
==smooth_8R8G8B_z_triangle
)
1341 _mesa_printf("smooth_8R8G8B_z_triangle\n");
1342 else if (triFunc
==smooth_8R8G8B24_z_triangle
)
1343 _mesa_printf("smooth_8R8G8B24_z_triangle\n");
1344 else if (triFunc
==smooth_TRUEDITHER_z_triangle
)
1345 _mesa_printf("smooth_TRUEDITHER_z_triangle\n");
1346 else if (triFunc
==smooth_5R6G5B_z_triangle
)
1347 _mesa_printf("smooth_5R6G5B_z_triangle\n");
1348 else if (triFunc
==smooth_DITHER_5R6G5B_z_triangle
)
1349 _mesa_printf("smooth_DITHER_5R6G5B_z_triangle\n");
1350 else if (triFunc
==smooth_HPCR_z_triangle
)
1351 _mesa_printf("smooth_HPCR_z_triangle\n");
1352 else if (triFunc
==smooth_DITHER8_z_triangle
)
1353 _mesa_printf("smooth_DITHER8_z_triangle\n");
1354 else if (triFunc
==smooth_LOOKUP8_z_triangle
)
1355 _mesa_printf("smooth_LOOKUP8_z_triangle\n");
1356 else if (triFunc
==flat_TRUECOLOR_z_triangle
)
1357 _mesa_printf("flat_TRUECOLOR_z_triangle\n");
1358 else if (triFunc
==flat_8A8B8G8R_z_triangle
)
1359 _mesa_printf("flat_8A8B8G8R_z_triangle\n");
1360 else if (triFunc
==flat_8A8R8G8B_z_triangle
)
1361 _mesa_printf("flat_8A8R8G8B_z_triangle\n");
1362 else if (triFunc
==flat_8R8G8B_z_triangle
)
1363 _mesa_printf("flat_8R8G8B_z_triangle\n");
1364 else if (triFunc
==flat_8R8G8B24_z_triangle
)
1365 _mesa_printf("flat_8R8G8B24_z_triangle\n");
1366 else if (triFunc
==flat_TRUEDITHER_z_triangle
)
1367 _mesa_printf("flat_TRUEDITHER_z_triangle\n");
1368 else if (triFunc
==flat_5R6G5B_z_triangle
)
1369 _mesa_printf("flat_5R6G5B_z_triangle\n");
1370 else if (triFunc
==flat_DITHER_5R6G5B_z_triangle
)
1371 _mesa_printf("flat_DITHER_5R6G5B_z_triangle\n");
1372 else if (triFunc
==flat_HPCR_z_triangle
)
1373 _mesa_printf("flat_HPCR_z_triangle\n");
1374 else if (triFunc
==flat_DITHER8_z_triangle
)
1375 _mesa_printf("flat_DITHER8_z_triangle\n");
1376 else if (triFunc
==flat_LOOKUP8_z_triangle
)
1377 _mesa_printf("flat_LOOKUP8_z_triangle\n");
1378 else if (triFunc
==smooth_TRUECOLOR_triangle
)
1379 _mesa_printf("smooth_TRUECOLOR_triangle\n");
1380 else if (triFunc
==smooth_8A8B8G8R_triangle
)
1381 _mesa_printf("smooth_8A8B8G8R_triangle\n");
1382 else if (triFunc
==smooth_8A8R8G8B_triangle
)
1383 _mesa_printf("smooth_8A8R8G8B_triangle\n");
1384 else if (triFunc
==smooth_8R8G8B_triangle
)
1385 _mesa_printf("smooth_8R8G8B_triangle\n");
1386 else if (triFunc
==smooth_8R8G8B24_triangle
)
1387 _mesa_printf("smooth_8R8G8B24_triangle\n");
1388 else if (triFunc
==smooth_TRUEDITHER_triangle
)
1389 _mesa_printf("smooth_TRUEDITHER_triangle\n");
1390 else if (triFunc
==smooth_5R6G5B_triangle
)
1391 _mesa_printf("smooth_5R6G5B_triangle\n");
1392 else if (triFunc
==smooth_DITHER_5R6G5B_triangle
)
1393 _mesa_printf("smooth_DITHER_5R6G5B_triangle\n");
1394 else if (triFunc
==smooth_HPCR_triangle
)
1395 _mesa_printf("smooth_HPCR_triangle\n");
1396 else if (triFunc
==smooth_DITHER8_triangle
)
1397 _mesa_printf("smooth_DITHER8_triangle\n");
1398 else if (triFunc
==smooth_LOOKUP8_triangle
)
1399 _mesa_printf("smooth_LOOKUP8_triangle\n");
1400 else if (triFunc
==flat_TRUECOLOR_triangle
)
1401 _mesa_printf("flat_TRUECOLOR_triangle\n");
1402 else if (triFunc
==flat_TRUEDITHER_triangle
)
1403 _mesa_printf("flat_TRUEDITHER_triangle\n");
1404 else if (triFunc
==flat_8A8B8G8R_triangle
)
1405 _mesa_printf("flat_8A8B8G8R_triangle\n");
1406 else if (triFunc
==flat_8A8R8G8B_triangle
)
1407 _mesa_printf("flat_8A8R8G8B_triangle\n");
1408 else if (triFunc
==flat_8R8G8B_triangle
)
1409 _mesa_printf("flat_8R8G8B_triangle\n");
1410 else if (triFunc
==flat_8R8G8B24_triangle
)
1411 _mesa_printf("flat_8R8G8B24_triangle\n");
1412 else if (triFunc
==flat_5R6G5B_triangle
)
1413 _mesa_printf("flat_5R6G5B_triangle\n");
1414 else if (triFunc
==flat_DITHER_5R6G5B_triangle
)
1415 _mesa_printf("flat_DITHER_5R6G5B_triangle\n");
1416 else if (triFunc
==flat_HPCR_triangle
)
1417 _mesa_printf("flat_HPCR_triangle\n");
1418 else if (triFunc
==flat_DITHER8_triangle
)
1419 _mesa_printf("flat_DITHER8_triangle\n");
1420 else if (triFunc
==flat_LOOKUP8_triangle
)
1421 _mesa_printf("flat_LOOKUP8_triangle\n");
1423 _mesa_printf("???\n");
1430 /* record the current triangle function name */
1431 static const char *triFuncName
= NULL
;
1433 #define USE(triFunc) \
1435 triFuncName = #triFunc; \
1441 #define USE(triFunc) return triFunc
1447 * Return pointer to line drawing function, or NULL if we should use a
1450 static swrast_tri_func
1451 get_triangle_func(GLcontext
*ctx
)
1454 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
1455 XMesaContext xmesa
= XMESA_CONTEXT(ctx
);
1456 XMesaBuffer xmbuf
= XMESA_BUFFER(ctx
->DrawBuffer
);
1457 const int depth
= GET_VISUAL_DEPTH(xmesa
->xm_visual
);
1458 const struct xmesa_renderbuffer
*xrb
;
1464 /* trivial fallback tests */
1465 if ((ctx
->DrawBuffer
->_ColorDrawBufferIndexes
[0] != BUFFER_BIT_FRONT_LEFT
) &&
1466 (ctx
->DrawBuffer
->_ColorDrawBufferIndexes
[0] != BUFFER_BIT_BACK_LEFT
))
1467 return (swrast_tri_func
) NULL
;
1468 if (ctx
->RenderMode
!= GL_RENDER
)
1469 return (swrast_tri_func
) NULL
;
1470 if (ctx
->Polygon
.SmoothFlag
)
1471 return (swrast_tri_func
) NULL
;
1472 if (ctx
->Texture
._EnabledUnits
)
1473 return (swrast_tri_func
) NULL
;
1474 if (swrast
->_RasterMask
& MULTI_DRAW_BIT
)
1475 return (swrast_tri_func
) NULL
;
1476 if (ctx
->Polygon
.CullFlag
&&
1477 ctx
->Polygon
.CullFaceMode
== GL_FRONT_AND_BACK
)
1478 return (swrast_tri_func
) NULL
;
1480 return (swrast_tri_func
) NULL
;
1482 xrb
= xmesa_renderbuffer(ctx
->DrawBuffer
->_ColorDrawBuffers
[0]->Wrapped
);
1485 if ( ctx
->Light
.ShadeModel
==GL_SMOOTH
1486 && swrast
->_RasterMask
==DEPTH_BIT
1487 && ctx
->Depth
.Func
==GL_LESS
1488 && ctx
->Depth
.Mask
==GL_TRUE
1489 && ctx
->Visual
.depthBits
== DEFAULT_SOFTWARE_DEPTH_BITS
1490 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1491 switch (xmesa
->pixelformat
) {
1493 USE(smooth_TRUECOLOR_z_triangle
);
1495 USE(smooth_8A8B8G8R_z_triangle
);
1497 USE(smooth_8A8R8G8B_z_triangle
);
1499 USE(smooth_8R8G8B_z_triangle
);
1501 USE(smooth_8R8G8B24_z_triangle
);
1502 case PF_Dither_True
:
1503 USE(smooth_TRUEDITHER_z_triangle
);
1505 USE(smooth_5R6G5B_z_triangle
);
1506 case PF_Dither_5R6G5B
:
1507 USE(smooth_DITHER_5R6G5B_z_triangle
);
1509 USE(smooth_HPCR_z_triangle
);
1512 USE(smooth_DITHER8_z_triangle
);
1514 USE(smooth_DITHER_z_triangle
);
1517 USE(smooth_LOOKUP8_z_triangle
);
1519 return (swrast_tri_func
) NULL
;
1521 return (swrast_tri_func
) NULL
;
1524 if ( ctx
->Light
.ShadeModel
==GL_FLAT
1525 && swrast
->_RasterMask
==DEPTH_BIT
1526 && ctx
->Depth
.Func
==GL_LESS
1527 && ctx
->Depth
.Mask
==GL_TRUE
1528 && ctx
->Visual
.depthBits
== DEFAULT_SOFTWARE_DEPTH_BITS
1529 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1530 switch (xmesa
->pixelformat
) {
1532 USE(flat_TRUECOLOR_z_triangle
);
1534 USE(flat_8A8B8G8R_z_triangle
);
1536 USE(flat_8A8R8G8B_z_triangle
);
1538 USE(flat_8R8G8B_z_triangle
);
1540 USE(flat_8R8G8B24_z_triangle
);
1541 case PF_Dither_True
:
1542 USE(flat_TRUEDITHER_z_triangle
);
1544 USE(flat_5R6G5B_z_triangle
);
1545 case PF_Dither_5R6G5B
:
1546 USE(flat_DITHER_5R6G5B_z_triangle
);
1548 USE(flat_HPCR_z_triangle
);
1551 USE(flat_DITHER8_z_triangle
);
1553 USE(flat_DITHER_z_triangle
);
1556 USE(flat_LOOKUP8_z_triangle
);
1558 return (swrast_tri_func
) NULL
;
1560 return (swrast_tri_func
) NULL
;
1563 if ( swrast
->_RasterMask
==0 /* no depth test */
1564 && ctx
->Light
.ShadeModel
==GL_SMOOTH
1565 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1566 switch (xmesa
->pixelformat
) {
1568 USE(smooth_TRUECOLOR_triangle
);
1570 USE(smooth_8A8B8G8R_triangle
);
1572 USE(smooth_8A8R8G8B_triangle
);
1574 USE(smooth_8R8G8B_triangle
);
1576 USE(smooth_8R8G8B24_triangle
);
1577 case PF_Dither_True
:
1578 USE(smooth_TRUEDITHER_triangle
);
1580 USE(smooth_5R6G5B_triangle
);
1581 case PF_Dither_5R6G5B
:
1582 USE(smooth_DITHER_5R6G5B_triangle
);
1584 USE(smooth_HPCR_triangle
);
1587 USE(smooth_DITHER8_triangle
);
1589 USE(smooth_DITHER_triangle
);
1592 USE(smooth_LOOKUP8_triangle
);
1594 return (swrast_tri_func
) NULL
;
1596 return (swrast_tri_func
) NULL
;
1600 if ( swrast
->_RasterMask
==0 /* no depth test */
1601 && ctx
->Light
.ShadeModel
==GL_FLAT
1602 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1603 switch (xmesa
->pixelformat
) {
1605 USE(flat_TRUECOLOR_triangle
);
1606 case PF_Dither_True
:
1607 USE(flat_TRUEDITHER_triangle
);
1609 USE(flat_8A8B8G8R_triangle
);
1611 USE(flat_8A8R8G8B_triangle
);
1613 USE(flat_8R8G8B_triangle
);
1615 USE(flat_8R8G8B24_triangle
);
1617 USE(flat_5R6G5B_triangle
);
1618 case PF_Dither_5R6G5B
:
1619 USE(flat_DITHER_5R6G5B_triangle
);
1621 USE(flat_HPCR_triangle
);
1624 USE(flat_DITHER8_triangle
);
1626 USE(flat_DITHER_triangle
);
1629 USE(flat_LOOKUP8_triangle
);
1631 return (swrast_tri_func
) NULL
;
1633 return (swrast_tri_func
) NULL
;
1637 #endif /* CHAN_BITS == 8 */
1639 return (swrast_tri_func
) NULL
;
1643 /* Override for the swrast tri-selection function. Try to use one
1644 * of our internal tri functions, otherwise fall back to the
1645 * standard swrast functions.
1647 void xmesa_choose_triangle( GLcontext
*ctx
)
1649 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
1651 if (!(swrast
->Triangle
= get_triangle_func( ctx
)))
1652 _swrast_choose_triangle( ctx
);