2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2004 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 "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 (struct xmesa_renderbuffer *) ctx->DrawBuffer->_ColorDrawBuffers[0][0]
51 /**********************************************************************/
52 /*** Triangle rendering ***/
53 /**********************************************************************/
57 * XImage, smooth, depth-buffered, PF_TRUECOLOR triangle.
59 #define NAME smooth_TRUECOLOR_z_triangle
61 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
64 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
67 #define RENDER_SPAN( span ) \
68 GLint x = span.x, y = YFLIP(xrb, span.y); \
70 for (i = 0; i < span.end; i++, x++) { \
71 const DEPTH_TYPE z = FixedToDepth(span.z); \
74 PACK_TRUECOLOR(p, FixedToInt(span.red), \
75 FixedToInt(span.green), FixedToInt(span.blue)); \
76 XMesaPutPixel(xrb->ximage, x, y, p); \
79 span.red += span.redStep; \
80 span.green += span.greenStep; \
81 span.blue += span.blueStep; \
82 span.z += span.zStep; \
85 #include "swrast/s_tritemp.h"
91 * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle.
93 #define NAME smooth_8A8B8G8R_z_triangle
95 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
97 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
98 #define PIXEL_TYPE GLuint
99 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
102 #define RENDER_SPAN( span ) \
104 for (i = 0; i < span.end; i++) { \
105 const DEPTH_TYPE z = FixedToDepth(span.z); \
107 pRow[i] = PACK_8B8G8R(FixedToInt(span.red), \
108 FixedToInt(span.green), FixedToInt(span.blue)); \
111 span.red += span.redStep; \
112 span.green += span.greenStep; \
113 span.blue += span.blueStep; \
114 span.z += span.zStep; \
117 #include "swrast/s_tritemp.h"
122 * XImage, smooth, depth-buffered, PF_8A8R8G8B triangle.
124 #define NAME smooth_8A8R8G8B_z_triangle
126 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
128 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
129 #define PIXEL_TYPE GLuint
130 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
134 #define RENDER_SPAN( span ) \
136 for (i = 0; i < span.end; i++) { \
137 const DEPTH_TYPE z = FixedToDepth(span.z); \
139 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
140 FixedToInt(span.green), FixedToInt(span.blue)); \
143 span.red += span.redStep; \
144 span.green += span.greenStep; \
145 span.blue += span.blueStep; \
146 span.z += span.zStep; \
149 #include "swrast/s_tritemp.h"
154 * XImage, smooth, depth-buffered, PF_8R8G8B triangle.
156 #define NAME smooth_8R8G8B_z_triangle
158 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
160 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
161 #define PIXEL_TYPE GLuint
162 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
166 #define RENDER_SPAN( span ) \
168 for (i = 0; i < span.end; i++) { \
169 const DEPTH_TYPE z = FixedToDepth(span.z); \
171 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
172 FixedToInt(span.green), FixedToInt(span.blue)); \
175 span.red += span.redStep; \
176 span.green += span.greenStep; \
177 span.blue += span.blueStep; \
178 span.z += span.zStep; \
181 #include "swrast/s_tritemp.h"
186 * XImage, smooth, depth-buffered, PF_8R8G8B24 triangle.
188 #define NAME smooth_8R8G8B24_z_triangle
190 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
192 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
193 #define PIXEL_TYPE bgr_t
194 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
197 #define RENDER_SPAN( span ) \
199 for (i = 0; i < span.end; i++) { \
200 const DEPTH_TYPE z = FixedToDepth(span.z); \
202 PIXEL_TYPE *ptr = pRow + i; \
203 ptr->r = FixedToInt(span.red); \
204 ptr->g = FixedToInt(span.green); \
205 ptr->b = FixedToInt(span.blue); \
208 span.red += span.redStep; \
209 span.green += span.greenStep; \
210 span.blue += span.blueStep; \
211 span.z += span.zStep; \
213 #include "swrast/s_tritemp.h"
218 * XImage, smooth, depth-buffered, PF_TRUEDITHER triangle.
220 #define NAME smooth_TRUEDITHER_z_triangle
222 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
225 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
227 #define RENDER_SPAN( span ) \
229 GLint x = span.x, y = YFLIP(xrb, span.y); \
230 for (i = 0; i < span.end; i++, x++) { \
231 const DEPTH_TYPE z = FixedToDepth(span.z); \
234 PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \
235 FixedToInt(span.green), FixedToInt(span.blue)); \
236 XMesaPutPixel(xrb->ximage, x, y, p); \
239 span.red += span.redStep; \
240 span.green += span.greenStep; \
241 span.blue += span.blueStep; \
242 span.z += span.zStep; \
244 #include "swrast/s_tritemp.h"
249 * XImage, smooth, depth-buffered, PF_5R6G5B triangle.
251 #define NAME smooth_5R6G5B_z_triangle
253 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
255 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
256 #define PIXEL_TYPE GLushort
257 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
260 #define RENDER_SPAN( span ) \
262 for (i = 0; i < span.end; i++) { \
263 const DEPTH_TYPE z = FixedToDepth(span.z); \
265 pRow[i] = PACK_5R6G5B(FixedToInt(span.red), \
266 FixedToInt(span.green), FixedToInt(span.blue)); \
269 span.red += span.redStep; \
270 span.green += span.greenStep; \
271 span.blue += span.blueStep; \
272 span.z += span.zStep; \
274 #include "swrast/s_tritemp.h"
279 * XImage, smooth, depth-buffered, PF_DITHER_5R6G5B triangle.
281 #define NAME smooth_DITHER_5R6G5B_z_triangle
283 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
285 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
286 #define PIXEL_TYPE GLushort
287 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
289 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
291 #define RENDER_SPAN( span ) \
293 GLint x = span.x, y = YFLIP(xrb, span.y); \
294 for (i = 0; i < span.end; i++, x++) { \
295 const DEPTH_TYPE z = FixedToDepth(span.z); \
297 PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \
298 FixedToInt(span.green), FixedToInt(span.blue)); \
301 span.red += span.redStep; \
302 span.green += span.greenStep; \
303 span.blue += span.blueStep; \
304 span.z += span.zStep; \
306 #include "swrast/s_tritemp.h"
311 * XImage, smooth, depth-buffered, 8-bit, PF_DITHER8 triangle.
313 #define NAME smooth_DITHER8_z_triangle
315 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
317 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
318 #define PIXEL_TYPE GLubyte
319 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
322 #define RENDER_SPAN( span ) \
324 GLint x = span.x, y = YFLIP(xrb, span.y); \
326 for (i = 0; i < span.end; i++, x++) { \
327 const DEPTH_TYPE z = FixedToDepth(span.z); \
329 pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red),\
330 FixedToInt(span.green), FixedToInt(span.blue) ); \
333 span.red += span.redStep; \
334 span.green += span.greenStep; \
335 span.blue += span.blueStep; \
336 span.z += span.zStep; \
338 #include "swrast/s_tritemp.h"
343 * XImage, smooth, depth-buffered, PF_DITHER triangle.
345 #define NAME smooth_DITHER_z_triangle
347 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
351 XMesaImage *img = xrb->ximage;
352 #define RENDER_SPAN( span ) \
354 GLint x = span.x, y = YFLIP(xrb, span.y); \
356 for (i = 0; i < span.end; i++, x++) { \
357 const DEPTH_TYPE z = FixedToDepth(span.z); \
359 unsigned long p = XDITHER(x, FixedToInt(span.red), \
360 FixedToInt(span.green), FixedToInt(span.blue)); \
361 XMesaPutPixel(img, x, y, p); \
364 span.red += span.redStep; \
365 span.green += span.greenStep; \
366 span.blue += span.blueStep; \
367 span.z += span.zStep; \
369 #include "swrast/s_tritemp.h"
374 * XImage, smooth, depth-buffered, 8-bit PF_LOOKUP triangle.
376 #define NAME smooth_LOOKUP8_z_triangle
378 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
380 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
381 #define PIXEL_TYPE GLubyte
382 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
385 #define RENDER_SPAN( span ) \
388 for (i = 0; i < span.end; i++) { \
389 const DEPTH_TYPE z = FixedToDepth(span.z); \
391 pRow[i] = LOOKUP(FixedToInt(span.red), \
392 FixedToInt(span.green), FixedToInt(span.blue)); \
395 span.red += span.redStep; \
396 span.green += span.greenStep; \
397 span.blue += span.blueStep; \
398 span.z += span.zStep; \
400 #include "swrast/s_tritemp.h"
405 * XImage, smooth, depth-buffered, 8-bit PF_HPCR triangle.
407 #define NAME smooth_HPCR_z_triangle
409 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
411 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
412 #define PIXEL_TYPE GLubyte
413 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
415 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
417 #define RENDER_SPAN( span ) \
419 GLint x = span.x, y = YFLIP(xrb, span.y); \
420 for (i = 0; i < span.end; i++, x++) { \
421 const DEPTH_TYPE z = FixedToDepth(span.z); \
423 pRow[i] = DITHER_HPCR(x, y, FixedToInt(span.red), \
424 FixedToInt(span.green), FixedToInt(span.blue) ); \
427 span.red += span.redStep; \
428 span.green += span.greenStep; \
429 span.blue += span.blueStep; \
430 span.z += span.zStep; \
432 #include "swrast/s_tritemp.h"
437 * XImage, flat, depth-buffered, PF_TRUECOLOR triangle.
439 #define NAME flat_TRUECOLOR_z_triangle
441 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
443 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
445 XMesaImage *img = xrb->ximage; \
446 unsigned long pixel; \
447 PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]);
448 #define RENDER_SPAN( span ) \
450 GLint x = span.x, y = YFLIP(xrb, span.y); \
451 for (i = 0; i < span.end; i++, x++) { \
452 const DEPTH_TYPE z = FixedToDepth(span.z); \
454 XMesaPutPixel(img, x, y, pixel); \
457 span.z += span.zStep; \
459 #include "swrast/s_tritemp.h"
464 * XImage, flat, depth-buffered, PF_8A8B8G8R triangle.
466 #define NAME flat_8A8B8G8R_z_triangle
468 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
469 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
470 #define PIXEL_TYPE GLuint
471 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
474 GLuint p = PACK_8B8G8R( v2->color[0], v2->color[1], v2->color[2] );
475 #define RENDER_SPAN( span ) \
477 for (i = 0; i < span.end; i++) { \
478 const DEPTH_TYPE z = FixedToDepth(span.z); \
480 pRow[i] = (PIXEL_TYPE) p; \
483 span.z += span.zStep; \
485 #include "swrast/s_tritemp.h"
490 * XImage, flat, depth-buffered, PF_8A8R8G8B triangle.
492 #define NAME flat_8A8R8G8B_z_triangle
494 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
495 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
496 #define PIXEL_TYPE GLuint
497 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
500 GLuint p = PACK_8R8G8B( v2->color[0], v2->color[1], v2->color[2] );
501 #define RENDER_SPAN( span ) \
503 for (i = 0; i < span.end; i++) { \
504 const DEPTH_TYPE z = FixedToDepth(span.z); \
506 pRow[i] = (PIXEL_TYPE) p; \
509 span.z += span.zStep; \
511 #include "swrast/s_tritemp.h"
516 * XImage, flat, depth-buffered, PF_8R8G8B triangle.
518 #define NAME flat_8R8G8B_z_triangle
520 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
521 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
522 #define PIXEL_TYPE GLuint
523 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
526 GLuint p = PACK_8R8G8B( v2->color[0], v2->color[1], v2->color[2] );
527 #define RENDER_SPAN( span ) \
529 for (i = 0; i < span.end; i++) { \
530 DEPTH_TYPE z = FixedToDepth(span.z); \
532 pRow[i] = (PIXEL_TYPE) p; \
534 if (span.y == 100) printf("pass\n");\
536 else if (span.y == 100) printf("fail\n");\
537 span.z += span.zStep; \
540 #include "swrast/s_tritemp.h"
545 * XImage, flat, depth-buffered, PF_8R8G8B24 triangle.
547 #define NAME flat_8R8G8B24_z_triangle
549 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
550 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
551 #define PIXEL_TYPE bgr_t
552 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
555 const GLubyte *color = v2->color;
556 #define RENDER_SPAN( span ) \
558 for (i = 0; i < span.end; i++) { \
559 const DEPTH_TYPE z = FixedToDepth(span.z); \
561 PIXEL_TYPE *ptr = pRow + i; \
562 ptr->r = color[RCOMP]; \
563 ptr->g = color[GCOMP]; \
564 ptr->b = color[BCOMP]; \
567 span.z += span.zStep; \
569 #include "swrast/s_tritemp.h"
574 * XImage, flat, depth-buffered, PF_TRUEDITHER triangle.
576 #define NAME flat_TRUEDITHER_z_triangle
578 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
580 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
582 XMesaImage *img = xrb->ximage;
583 #define RENDER_SPAN( span ) \
585 GLint x = span.x, y = YFLIP(xrb, span.y); \
586 for (i = 0; i < span.end; i++, x++) { \
587 const DEPTH_TYPE z = FixedToDepth(span.z); \
590 PACK_TRUEDITHER(p, x, y, v2->color[0], \
591 v2->color[1], v2->color[2]); \
592 XMesaPutPixel(img, x, y, p); \
595 span.z += span.zStep; \
597 #include "swrast/s_tritemp.h"
602 * XImage, flat, depth-buffered, PF_5R6G5B triangle.
604 #define NAME flat_5R6G5B_z_triangle
606 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
607 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
608 #define PIXEL_TYPE GLushort
609 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
612 GLushort p = PACK_5R6G5B( v2->color[0], v2->color[1], v2->color[2] );
613 #define RENDER_SPAN( span ) \
615 for (i = 0; i < span.end; i++) { \
616 const DEPTH_TYPE z = FixedToDepth(span.z); \
618 pRow[i] = (PIXEL_TYPE) p; \
621 span.z += span.zStep; \
623 #include "swrast/s_tritemp.h"
628 * XImage, flat, depth-buffered, PF_DITHER_5R6G5B triangle.
630 #define NAME flat_DITHER_5R6G5B_z_triangle
632 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
633 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
634 #define PIXEL_TYPE GLushort
635 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
637 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
639 const GLubyte *color = v2->color;
640 #define RENDER_SPAN( span ) \
642 GLint x = span.x, y = YFLIP(xrb, span.y); \
643 for (i = 0; i < span.end; i++, x++) { \
644 const DEPTH_TYPE z = FixedToDepth(span.z); \
646 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \
647 color[GCOMP], color[BCOMP]); \
650 span.z += span.zStep; \
652 #include "swrast/s_tritemp.h"
657 * XImage, flat, depth-buffered, 8-bit PF_DITHER triangle.
659 #define NAME flat_DITHER8_z_triangle
661 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
662 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
663 #define PIXEL_TYPE GLubyte
664 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
667 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
668 #define RENDER_SPAN( span ) \
670 GLint x = span.x, y = YFLIP(xrb, span.y); \
671 FLAT_DITHER_ROW_SETUP(YFLIP(xrb, y)); \
672 for (i = 0; i < span.end; i++, x++) { \
673 const DEPTH_TYPE z = FixedToDepth(span.z); \
675 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x); \
678 span.z += span.zStep; \
680 #include "swrast/s_tritemp.h"
685 * XImage, flat, depth-buffered, PF_DITHER triangle.
687 #define NAME flat_DITHER_z_triangle
689 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
692 XMesaImage *img = xrb->ximage; \
693 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
694 #define RENDER_SPAN( span ) \
696 GLint x = span.x, y = YFLIP(xrb, span.y); \
697 FLAT_DITHER_ROW_SETUP(y); \
698 for (i = 0; i < span.end; i++, x++) { \
699 const DEPTH_TYPE z = FixedToDepth(span.z); \
701 unsigned long p = FLAT_DITHER(x); \
702 XMesaPutPixel(img, x, y, p); \
705 span.z += span.zStep; \
707 #include "swrast/s_tritemp.h"
712 * XImage, flat, depth-buffered, 8-bit PF_HPCR triangle.
714 #define NAME flat_HPCR_z_triangle
716 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
717 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
718 #define PIXEL_TYPE GLubyte
719 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
721 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
723 GLubyte r = v2->color[0]; \
724 GLubyte g = v2->color[1]; \
725 GLubyte b = v2->color[2];
726 #define RENDER_SPAN( span ) \
728 GLint x = span.x, y = YFLIP(xrb, span.y); \
729 for (i = 0; i < span.end; i++, x++) { \
730 const DEPTH_TYPE z = FixedToDepth(span.z); \
732 pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b); \
735 span.z += span.zStep; \
737 #include "swrast/s_tritemp.h"
742 * XImage, flat, depth-buffered, 8-bit PF_LOOKUP triangle.
744 #define NAME flat_LOOKUP8_z_triangle
746 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
747 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
748 #define PIXEL_TYPE GLubyte
749 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
753 GLubyte r = v2->color[0]; \
754 GLubyte g = v2->color[1]; \
755 GLubyte b = v2->color[2]; \
756 GLubyte p = LOOKUP(r,g,b);
757 #define RENDER_SPAN( span ) \
759 for (i = 0; i < span.end; i++) { \
760 const DEPTH_TYPE z = FixedToDepth(span.z); \
765 span.z += span.zStep; \
767 #include "swrast/s_tritemp.h"
772 * XImage, smooth, NON-depth-buffered, PF_TRUECOLOR triangle.
774 #define NAME smooth_TRUECOLOR_triangle
777 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
779 XMesaImage *img = xrb->ximage;
780 #define RENDER_SPAN( span ) \
782 GLint x = span.x, y = YFLIP(xrb, span.y); \
783 for (i = 0; i < span.end; i++, x++) { \
785 PACK_TRUECOLOR(p, FixedToInt(span.red), \
786 FixedToInt(span.green), FixedToInt(span.blue)); \
787 XMesaPutPixel(img, x, y, p); \
788 span.red += span.redStep; \
789 span.green += span.greenStep; \
790 span.blue += span.blueStep; \
792 #include "swrast/s_tritemp.h"
797 * XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle.
799 #define NAME smooth_8A8B8G8R_triangle
801 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
802 #define PIXEL_TYPE GLuint
803 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
806 #define RENDER_SPAN( span ) \
808 for (i = 0; i < span.end; i++) { \
809 pRow[i] = PACK_8B8G8R(FixedToInt(span.red), \
810 FixedToInt(span.green), FixedToInt(span.blue) ); \
811 span.red += span.redStep; \
812 span.green += span.greenStep; \
813 span.blue += span.blueStep; \
815 #include "swrast/s_tritemp.h"
820 * XImage, smooth, NON-depth-buffered, PF_8A8R8G8B triangle.
822 #define NAME smooth_8A8R8G8B_triangle
824 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
825 #define PIXEL_TYPE GLuint
826 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
829 #define RENDER_SPAN( span ) \
831 for (i = 0; i < span.end; i++) { \
832 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
833 FixedToInt(span.green), FixedToInt(span.blue) ); \
834 span.red += span.redStep; \
835 span.green += span.greenStep; \
836 span.blue += span.blueStep; \
838 #include "swrast/s_tritemp.h"
843 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
845 #define NAME smooth_8R8G8B_triangle
847 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
848 #define PIXEL_TYPE GLuint
849 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
852 #define RENDER_SPAN( span ) \
854 for (i = 0; i < span.end; i++) { \
855 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
856 FixedToInt(span.green), FixedToInt(span.blue) ); \
857 span.red += span.redStep; \
858 span.green += span.greenStep; \
859 span.blue += span.blueStep; \
861 #include "swrast/s_tritemp.h"
866 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
868 #define NAME smooth_8R8G8B24_triangle
870 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
871 #define PIXEL_TYPE bgr_t
872 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
875 #define RENDER_SPAN( span ) \
877 PIXEL_TYPE *pixel = pRow; \
878 for (i = 0; i < span.end; i++, pixel++) { \
879 pixel->r = FixedToInt(span.red); \
880 pixel->g = FixedToInt(span.green); \
881 pixel->b = FixedToInt(span.blue); \
882 span.red += span.redStep; \
883 span.green += span.greenStep; \
884 span.blue += span.blueStep; \
886 #include "swrast/s_tritemp.h"
891 * XImage, smooth, NON-depth-buffered, PF_TRUEDITHER triangle.
893 #define NAME smooth_TRUEDITHER_triangle
896 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
898 XMesaImage *img = xrb->ximage;
899 #define RENDER_SPAN( span ) \
901 GLint x = span.x, y = YFLIP(xrb, span.y); \
902 for (i = 0; i < span.end; i++, x++) { \
904 PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \
905 FixedToInt(span.green), FixedToInt(span.blue)); \
906 XMesaPutPixel(img, x, y, p ); \
907 span.red += span.redStep; \
908 span.green += span.greenStep; \
909 span.blue += span.blueStep; \
911 #include "swrast/s_tritemp.h"
916 * XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle.
918 #define NAME smooth_5R6G5B_triangle
920 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
921 #define PIXEL_TYPE GLushort
922 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
925 #define RENDER_SPAN( span ) \
927 for (i = 0; i < span.end; i++) { \
928 pRow[i] = (PIXEL_TYPE) PACK_5R6G5B(FixedToInt(span.red), \
929 FixedToInt(span.green), FixedToInt(span.blue)); \
930 span.red += span.redStep; \
931 span.green += span.greenStep; \
932 span.blue += span.blueStep; \
934 #include "swrast/s_tritemp.h"
939 * XImage, smooth, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
941 #define NAME smooth_DITHER_5R6G5B_triangle
943 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
944 #define PIXEL_TYPE GLushort
945 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
947 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
949 #define RENDER_SPAN( span ) \
951 GLint x = span.x, y = YFLIP(xrb, span.y); \
952 for (i = 0; i < span.end; i++, x++) { \
953 PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \
954 FixedToInt(span.green), FixedToInt(span.blue)); \
955 span.red += span.redStep; \
956 span.green += span.greenStep; \
957 span.blue += span.blueStep; \
959 #include "swrast/s_tritemp.h"
964 * XImage, smooth, NON-depth-buffered, 8-bit PF_DITHER triangle.
966 #define NAME smooth_DITHER8_triangle
968 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
969 #define PIXEL_TYPE GLubyte
970 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
973 #define RENDER_SPAN( span ) \
975 GLint x = span.x, y = YFLIP(xrb, span.y); \
977 for (i = 0; i < span.end; i++, x++) { \
978 pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red), \
979 FixedToInt(span.green), FixedToInt(span.blue) ); \
980 span.red += span.redStep; \
981 span.green += span.greenStep; \
982 span.blue += span.blueStep; \
984 #include "swrast/s_tritemp.h"
989 * XImage, smooth, NON-depth-buffered, PF_DITHER triangle.
991 #define NAME smooth_DITHER_triangle
995 XMesaImage *img = xrb->ximage;
996 #define RENDER_SPAN( span ) \
998 GLint x = span.x, y = YFLIP(xrb, span.y); \
1000 for (i = 0; i < span.end; i++, x++) { \
1001 unsigned long p = XDITHER(x, FixedToInt(span.red), \
1002 FixedToInt(span.green), FixedToInt(span.blue) ); \
1003 XMesaPutPixel(img, x, y, p); \
1004 span.red += span.redStep; \
1005 span.green += span.greenStep; \
1006 span.blue += span.blueStep; \
1008 #include "swrast/s_tritemp.h"
1013 * XImage, smooth, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
1015 #define NAME smooth_LOOKUP8_triangle
1016 #define INTERP_RGB 1
1017 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
1018 #define PIXEL_TYPE GLubyte
1019 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1020 #define SETUP_CODE \
1022 #define RENDER_SPAN( span ) \
1025 for (i = 0; i < span.end; i++) { \
1026 pRow[i] = LOOKUP(FixedToInt(span.red), \
1027 FixedToInt(span.green), FixedToInt(span.blue)); \
1028 span.red += span.redStep; \
1029 span.green += span.greenStep; \
1030 span.blue += span.blueStep; \
1032 #include "swrast/s_tritemp.h"
1037 * XImage, smooth, NON-depth-buffered, 8-bit PF_HPCR triangle.
1039 #define NAME smooth_HPCR_triangle
1040 #define INTERP_RGB 1
1041 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
1042 #define PIXEL_TYPE GLubyte
1043 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1044 #define SETUP_CODE \
1045 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1047 #define RENDER_SPAN( span ) \
1049 GLint x = span.x, y = YFLIP(xrb, span.y); \
1050 for (i = 0; i < span.end; i++, x++) { \
1051 pRow[i] = DITHER_HPCR(x, y, FixedToInt(span.red), \
1052 FixedToInt(span.green), FixedToInt(span.blue)); \
1053 span.red += span.redStep; \
1054 span.green += span.greenStep; \
1055 span.blue += span.blueStep; \
1057 #include "swrast/s_tritemp.h"
1062 * XImage, flat, NON-depth-buffered, PF_TRUECOLOR triangle.
1064 #define NAME flat_TRUECOLOR_triangle
1065 #define SETUP_CODE \
1066 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1068 XMesaImage *img = xrb->ximage; \
1069 unsigned long pixel; \
1070 PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]);
1071 #define RENDER_SPAN( span ) \
1073 GLint x = span.x, y = YFLIP(xrb, span.y); \
1074 for (i = 0; i < span.end; i++, x++) { \
1075 XMesaPutPixel(img, x, y, pixel); \
1077 #include "swrast/s_tritemp.h"
1082 * XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle.
1084 #define NAME flat_8A8B8G8R_triangle
1085 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
1086 #define PIXEL_TYPE GLuint
1087 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1088 #define SETUP_CODE \
1090 unsigned long p = PACK_8B8G8R( v2->color[0], \
1091 v2->color[1], v2->color[2] );
1092 #define RENDER_SPAN( span ) \
1094 for (i = 0; i < span.end; i++) { \
1095 pRow[i] = (PIXEL_TYPE) p; \
1097 #include "swrast/s_tritemp.h"
1102 * XImage, flat, NON-depth-buffered, PF_8A8R8G8B triangle.
1104 #define NAME flat_8A8R8G8B_triangle
1105 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
1106 #define PIXEL_TYPE GLuint
1107 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1108 #define SETUP_CODE \
1110 unsigned long p = PACK_8R8G8B( v2->color[0], \
1111 v2->color[1], v2->color[2] );
1112 #define RENDER_SPAN( span ) \
1114 for (i = 0; i < span.end; i++) { \
1115 pRow[i] = (PIXEL_TYPE) p; \
1117 #include "swrast/s_tritemp.h"
1122 * XImage, flat, NON-depth-buffered, PF_8R8G8B triangle.
1124 #define NAME flat_8R8G8B_triangle
1125 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
1126 #define PIXEL_TYPE GLuint
1127 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1128 #define SETUP_CODE \
1130 unsigned long p = PACK_8R8G8B( v2->color[0], \
1131 v2->color[1], v2->color[2] );
1132 #define RENDER_SPAN( span ) \
1134 for (i = 0; i < span.end; i++) { \
1135 pRow[i] = (PIXEL_TYPE) p; \
1137 #include "swrast/s_tritemp.h"
1142 * XImage, flat, NON-depth-buffered, PF_8R8G8B24 triangle.
1144 #define NAME flat_8R8G8B24_triangle
1145 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
1146 #define PIXEL_TYPE bgr_t
1147 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1148 #define SETUP_CODE \
1150 const GLubyte *color = v2->color;
1151 #define RENDER_SPAN( span ) \
1153 PIXEL_TYPE *pixel = pRow; \
1154 for (i = 0; i < span.end; i++, pixel++) { \
1155 pixel->r = color[RCOMP]; \
1156 pixel->g = color[GCOMP]; \
1157 pixel->b = color[BCOMP]; \
1159 #include "swrast/s_tritemp.h"
1164 * XImage, flat, NON-depth-buffered, PF_TRUEDITHER triangle.
1166 #define NAME flat_TRUEDITHER_triangle
1167 #define SETUP_CODE \
1168 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1170 XMesaImage *img = xrb->ximage;
1171 #define RENDER_SPAN( span ) \
1173 GLint x = span.x, y = YFLIP(xrb, span.y); \
1174 for (i = 0; i < span.end; i++, x++) { \
1176 PACK_TRUEDITHER(p, x, y, v2->color[0], \
1177 v2->color[1], v2->color[2] ); \
1178 XMesaPutPixel(img, x, y, p); \
1180 #include "swrast/s_tritemp.h"
1185 * XImage, flat, NON-depth-buffered, PF_5R6G5B triangle.
1187 #define NAME flat_5R6G5B_triangle
1188 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
1189 #define PIXEL_TYPE GLushort
1190 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1191 #define SETUP_CODE \
1193 unsigned long p = PACK_5R6G5B( v2->color[0], \
1194 v2->color[1], v2->color[2] );
1195 #define RENDER_SPAN( span ) \
1197 for (i = 0; i < span.end; i++) { \
1198 pRow[i] = (PIXEL_TYPE) p; \
1200 #include "swrast/s_tritemp.h"
1205 * XImage, flat, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
1207 #define NAME flat_DITHER_5R6G5B_triangle
1208 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
1209 #define PIXEL_TYPE GLushort
1210 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1211 #define SETUP_CODE \
1212 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1214 const GLubyte *color = v2->color;
1215 #define RENDER_SPAN( span ) \
1217 GLint x = span.x, y = YFLIP(xrb, span.y); \
1218 for (i = 0; i < span.end; i++, x++) { \
1219 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \
1220 color[GCOMP], color[BCOMP]); \
1222 #include "swrast/s_tritemp.h"
1227 * XImage, flat, NON-depth-buffered, 8-bit PF_DITHER triangle.
1229 #define NAME flat_DITHER8_triangle
1230 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
1231 #define PIXEL_TYPE GLubyte
1232 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1233 #define SETUP_CODE \
1235 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
1236 #define RENDER_SPAN( span ) \
1238 GLint x = span.x, y = YFLIP(xrb, span.y); \
1239 FLAT_DITHER_ROW_SETUP(YFLIP(xrb, y)); \
1240 for (i = 0; i < span.end; i++, x++) { \
1241 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x); \
1243 #include "swrast/s_tritemp.h"
1248 * XImage, flat, NON-depth-buffered, PF_DITHER triangle.
1250 #define NAME flat_DITHER_triangle
1251 #define SETUP_CODE \
1253 XMesaImage *img = xrb->ximage; \
1254 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
1255 #define RENDER_SPAN( span ) \
1257 GLint x = span.x, y = YFLIP(xrb, span.y); \
1258 FLAT_DITHER_ROW_SETUP(y); \
1259 for (i = 0; i < span.end; i++, x++) { \
1260 unsigned long p = FLAT_DITHER(x); \
1261 XMesaPutPixel(img, x, y, p ); \
1263 #include "swrast/s_tritemp.h"
1268 * XImage, flat, NON-depth-buffered, 8-bit PF_HPCR triangle.
1270 #define NAME flat_HPCR_triangle
1271 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
1272 #define PIXEL_TYPE GLubyte
1273 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1274 #define SETUP_CODE \
1275 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1277 GLubyte r = v2->color[0]; \
1278 GLubyte g = v2->color[1]; \
1279 GLubyte b = v2->color[2];
1280 #define RENDER_SPAN( span ) \
1282 GLint x = span.x, y = YFLIP(xrb, span.y); \
1283 for (i = 0; i < span.end; i++, x++) { \
1284 pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b); \
1286 #include "swrast/s_tritemp.h"
1291 * XImage, flat, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
1293 #define NAME flat_LOOKUP8_triangle
1294 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
1295 #define PIXEL_TYPE GLubyte
1296 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1297 #define SETUP_CODE \
1300 GLubyte r = v2->color[0]; \
1301 GLubyte g = v2->color[1]; \
1302 GLubyte b = v2->color[2]; \
1303 GLubyte p = LOOKUP(r,g,b);
1304 #define RENDER_SPAN( span ) \
1306 for (i = 0; i < span.end; i++) { \
1307 pRow[i] = (PIXEL_TYPE) p; \
1309 #include "swrast/s_tritemp.h"
1314 extern void _xmesa_print_triangle_func( swrast_tri_func triFunc
);
1315 void _xmesa_print_triangle_func( swrast_tri_func triFunc
)
1317 _mesa_printf("XMesa tri func = ");
1318 if (triFunc
==smooth_TRUECOLOR_z_triangle
)
1319 _mesa_printf("smooth_TRUECOLOR_z_triangle\n");
1320 else if (triFunc
==smooth_8A8B8G8R_z_triangle
)
1321 _mesa_printf("smooth_8A8B8G8R_z_triangle\n");
1322 else if (triFunc
==smooth_8A8R8G8B_z_triangle
)
1323 _mesa_printf("smooth_8A8R8G8B_z_triangle\n");
1324 else if (triFunc
==smooth_8R8G8B_z_triangle
)
1325 _mesa_printf("smooth_8R8G8B_z_triangle\n");
1326 else if (triFunc
==smooth_8R8G8B24_z_triangle
)
1327 _mesa_printf("smooth_8R8G8B24_z_triangle\n");
1328 else if (triFunc
==smooth_TRUEDITHER_z_triangle
)
1329 _mesa_printf("smooth_TRUEDITHER_z_triangle\n");
1330 else if (triFunc
==smooth_5R6G5B_z_triangle
)
1331 _mesa_printf("smooth_5R6G5B_z_triangle\n");
1332 else if (triFunc
==smooth_DITHER_5R6G5B_z_triangle
)
1333 _mesa_printf("smooth_DITHER_5R6G5B_z_triangle\n");
1334 else if (triFunc
==smooth_HPCR_z_triangle
)
1335 _mesa_printf("smooth_HPCR_z_triangle\n");
1336 else if (triFunc
==smooth_DITHER8_z_triangle
)
1337 _mesa_printf("smooth_DITHER8_z_triangle\n");
1338 else if (triFunc
==smooth_LOOKUP8_z_triangle
)
1339 _mesa_printf("smooth_LOOKUP8_z_triangle\n");
1340 else if (triFunc
==flat_TRUECOLOR_z_triangle
)
1341 _mesa_printf("flat_TRUECOLOR_z_triangle\n");
1342 else if (triFunc
==flat_8A8B8G8R_z_triangle
)
1343 _mesa_printf("flat_8A8B8G8R_z_triangle\n");
1344 else if (triFunc
==flat_8A8R8G8B_z_triangle
)
1345 _mesa_printf("flat_8A8R8G8B_z_triangle\n");
1346 else if (triFunc
==flat_8R8G8B_z_triangle
)
1347 _mesa_printf("flat_8R8G8B_z_triangle\n");
1348 else if (triFunc
==flat_8R8G8B24_z_triangle
)
1349 _mesa_printf("flat_8R8G8B24_z_triangle\n");
1350 else if (triFunc
==flat_TRUEDITHER_z_triangle
)
1351 _mesa_printf("flat_TRUEDITHER_z_triangle\n");
1352 else if (triFunc
==flat_5R6G5B_z_triangle
)
1353 _mesa_printf("flat_5R6G5B_z_triangle\n");
1354 else if (triFunc
==flat_DITHER_5R6G5B_z_triangle
)
1355 _mesa_printf("flat_DITHER_5R6G5B_z_triangle\n");
1356 else if (triFunc
==flat_HPCR_z_triangle
)
1357 _mesa_printf("flat_HPCR_z_triangle\n");
1358 else if (triFunc
==flat_DITHER8_z_triangle
)
1359 _mesa_printf("flat_DITHER8_z_triangle\n");
1360 else if (triFunc
==flat_LOOKUP8_z_triangle
)
1361 _mesa_printf("flat_LOOKUP8_z_triangle\n");
1362 else if (triFunc
==smooth_TRUECOLOR_triangle
)
1363 _mesa_printf("smooth_TRUECOLOR_triangle\n");
1364 else if (triFunc
==smooth_8A8B8G8R_triangle
)
1365 _mesa_printf("smooth_8A8B8G8R_triangle\n");
1366 else if (triFunc
==smooth_8A8R8G8B_triangle
)
1367 _mesa_printf("smooth_8A8R8G8B_triangle\n");
1368 else if (triFunc
==smooth_8R8G8B_triangle
)
1369 _mesa_printf("smooth_8R8G8B_triangle\n");
1370 else if (triFunc
==smooth_8R8G8B24_triangle
)
1371 _mesa_printf("smooth_8R8G8B24_triangle\n");
1372 else if (triFunc
==smooth_TRUEDITHER_triangle
)
1373 _mesa_printf("smooth_TRUEDITHER_triangle\n");
1374 else if (triFunc
==smooth_5R6G5B_triangle
)
1375 _mesa_printf("smooth_5R6G5B_triangle\n");
1376 else if (triFunc
==smooth_DITHER_5R6G5B_triangle
)
1377 _mesa_printf("smooth_DITHER_5R6G5B_triangle\n");
1378 else if (triFunc
==smooth_HPCR_triangle
)
1379 _mesa_printf("smooth_HPCR_triangle\n");
1380 else if (triFunc
==smooth_DITHER8_triangle
)
1381 _mesa_printf("smooth_DITHER8_triangle\n");
1382 else if (triFunc
==smooth_LOOKUP8_triangle
)
1383 _mesa_printf("smooth_LOOKUP8_triangle\n");
1384 else if (triFunc
==flat_TRUECOLOR_triangle
)
1385 _mesa_printf("flat_TRUECOLOR_triangle\n");
1386 else if (triFunc
==flat_TRUEDITHER_triangle
)
1387 _mesa_printf("flat_TRUEDITHER_triangle\n");
1388 else if (triFunc
==flat_8A8B8G8R_triangle
)
1389 _mesa_printf("flat_8A8B8G8R_triangle\n");
1390 else if (triFunc
==flat_8A8R8G8B_triangle
)
1391 _mesa_printf("flat_8A8R8G8B_triangle\n");
1392 else if (triFunc
==flat_8R8G8B_triangle
)
1393 _mesa_printf("flat_8R8G8B_triangle\n");
1394 else if (triFunc
==flat_8R8G8B24_triangle
)
1395 _mesa_printf("flat_8R8G8B24_triangle\n");
1396 else if (triFunc
==flat_5R6G5B_triangle
)
1397 _mesa_printf("flat_5R6G5B_triangle\n");
1398 else if (triFunc
==flat_DITHER_5R6G5B_triangle
)
1399 _mesa_printf("flat_DITHER_5R6G5B_triangle\n");
1400 else if (triFunc
==flat_HPCR_triangle
)
1401 _mesa_printf("flat_HPCR_triangle\n");
1402 else if (triFunc
==flat_DITHER8_triangle
)
1403 _mesa_printf("flat_DITHER8_triangle\n");
1404 else if (triFunc
==flat_LOOKUP8_triangle
)
1405 _mesa_printf("flat_LOOKUP8_triangle\n");
1407 _mesa_printf("???\n");
1414 /* record the current triangle function name */
1415 static const char *triFuncName
= NULL
;
1417 #define USE(triFunc) \
1419 triFuncName = #triFunc; \
1425 #define USE(triFunc) return triFunc
1430 static swrast_tri_func
get_triangle_func( GLcontext
*ctx
)
1432 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
1433 XMesaContext xmesa
= XMESA_CONTEXT(ctx
);
1434 int depth
= GET_VISUAL_DEPTH(xmesa
->xm_visual
);
1435 struct xmesa_renderbuffer
*xrb
= (struct xmesa_renderbuffer
*)
1436 ctx
->DrawBuffer
->_ColorDrawBuffers
[0][0];
1443 if ((ctx
->DrawBuffer
->_ColorDrawBufferMask
[0]
1444 & (BUFFER_BIT_FRONT_LEFT
| BUFFER_BIT_BACK_LEFT
)) == 0)
1445 return (swrast_tri_func
) NULL
;
1446 if (ctx
->RenderMode
!= GL_RENDER
) return (swrast_tri_func
) NULL
;
1447 if (ctx
->Polygon
.SmoothFlag
) return (swrast_tri_func
) NULL
;
1448 if (ctx
->Texture
._EnabledUnits
) return (swrast_tri_func
) NULL
;
1449 if (swrast
->_RasterMask
& MULTI_DRAW_BIT
) return (swrast_tri_func
) NULL
;
1450 if (ctx
->Polygon
.CullFlag
&&
1451 ctx
->Polygon
.CullFaceMode
== GL_FRONT_AND_BACK
)
1452 return (swrast_tri_func
) NULL
;
1455 if ( ctx
->Light
.ShadeModel
==GL_SMOOTH
1456 && swrast
->_RasterMask
==DEPTH_BIT
1457 && ctx
->Depth
.Func
==GL_LESS
1458 && ctx
->Depth
.Mask
==GL_TRUE
1459 && ctx
->Visual
.depthBits
== DEFAULT_SOFTWARE_DEPTH_BITS
1460 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1461 switch (xmesa
->pixelformat
) {
1463 USE(smooth_TRUECOLOR_z_triangle
);
1465 USE(smooth_8A8B8G8R_z_triangle
);
1467 USE(smooth_8A8R8G8B_z_triangle
);
1469 USE(smooth_8R8G8B_z_triangle
);
1471 USE(smooth_8R8G8B24_z_triangle
);
1472 case PF_Dither_True
:
1473 USE(smooth_TRUEDITHER_z_triangle
);
1475 USE(smooth_5R6G5B_z_triangle
);
1476 case PF_Dither_5R6G5B
:
1477 USE(smooth_DITHER_5R6G5B_z_triangle
);
1479 USE(smooth_HPCR_z_triangle
);
1482 USE(smooth_DITHER8_z_triangle
);
1484 USE(smooth_DITHER_z_triangle
);
1487 USE(smooth_LOOKUP8_z_triangle
);
1489 return (swrast_tri_func
) NULL
;
1491 return (swrast_tri_func
) NULL
;
1494 if ( ctx
->Light
.ShadeModel
==GL_FLAT
1495 && swrast
->_RasterMask
==DEPTH_BIT
1496 && ctx
->Depth
.Func
==GL_LESS
1497 && ctx
->Depth
.Mask
==GL_TRUE
1498 && ctx
->Visual
.depthBits
== DEFAULT_SOFTWARE_DEPTH_BITS
1499 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1500 switch (xmesa
->pixelformat
) {
1502 USE(flat_TRUECOLOR_z_triangle
);
1504 USE(flat_8A8B8G8R_z_triangle
);
1506 USE(flat_8A8R8G8B_z_triangle
);
1508 USE(flat_8R8G8B_z_triangle
);
1510 USE(flat_8R8G8B24_z_triangle
);
1511 case PF_Dither_True
:
1512 USE(flat_TRUEDITHER_z_triangle
);
1514 USE(flat_5R6G5B_z_triangle
);
1515 case PF_Dither_5R6G5B
:
1516 USE(flat_DITHER_5R6G5B_z_triangle
);
1518 USE(flat_HPCR_z_triangle
);
1521 USE(flat_DITHER8_z_triangle
);
1523 USE(flat_DITHER_z_triangle
);
1526 USE(flat_LOOKUP8_z_triangle
);
1528 return (swrast_tri_func
) NULL
;
1530 return (swrast_tri_func
) NULL
;
1533 if ( swrast
->_RasterMask
==0 /* no depth test */
1534 && ctx
->Light
.ShadeModel
==GL_SMOOTH
1535 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1536 switch (xmesa
->pixelformat
) {
1538 USE(smooth_TRUECOLOR_triangle
);
1540 USE(smooth_8A8B8G8R_triangle
);
1542 USE(smooth_8A8R8G8B_triangle
);
1544 USE(smooth_8R8G8B_triangle
);
1546 USE(smooth_8R8G8B24_triangle
);
1547 case PF_Dither_True
:
1548 USE(smooth_TRUEDITHER_triangle
);
1550 USE(smooth_5R6G5B_triangle
);
1551 case PF_Dither_5R6G5B
:
1552 USE(smooth_DITHER_5R6G5B_triangle
);
1554 USE(smooth_HPCR_triangle
);
1557 USE(smooth_DITHER8_triangle
);
1559 USE(smooth_DITHER_triangle
);
1562 USE(smooth_LOOKUP8_triangle
);
1564 return (swrast_tri_func
) NULL
;
1566 return (swrast_tri_func
) NULL
;
1570 if ( swrast
->_RasterMask
==0 /* no depth test */
1571 && ctx
->Light
.ShadeModel
==GL_FLAT
1572 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1573 switch (xmesa
->pixelformat
) {
1575 USE(flat_TRUECOLOR_triangle
);
1576 case PF_Dither_True
:
1577 USE(flat_TRUEDITHER_triangle
);
1579 USE(flat_8A8B8G8R_triangle
);
1581 USE(flat_8A8R8G8B_triangle
);
1583 USE(flat_8R8G8B_triangle
);
1585 USE(flat_8R8G8B24_triangle
);
1587 USE(flat_5R6G5B_triangle
);
1588 case PF_Dither_5R6G5B
:
1589 USE(flat_DITHER_5R6G5B_triangle
);
1591 USE(flat_HPCR_triangle
);
1594 USE(flat_DITHER8_triangle
);
1596 USE(flat_DITHER_triangle
);
1599 USE(flat_LOOKUP8_triangle
);
1601 return (swrast_tri_func
) NULL
;
1603 return (swrast_tri_func
) NULL
;
1607 return (swrast_tri_func
) NULL
;
1610 /* draw to pixmap */
1611 return (swrast_tri_func
) NULL
;
1616 /* Override for the swrast tri-selection function. Try to use one
1617 * of our internal tri functions, otherwise fall back to the
1618 * standard swrast functions.
1620 void xmesa_choose_triangle( GLcontext
*ctx
)
1622 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
1624 if (!(swrast
->Triangle
= get_triangle_func( ctx
)))
1625 _swrast_choose_triangle( ctx
);