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"
48 /**********************************************************************/
49 /*** Triangle rendering ***/
50 /**********************************************************************/
54 * XImage, smooth, depth-buffered, PF_TRUECOLOR triangle.
56 #define NAME smooth_TRUECOLOR_z_triangle
58 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
61 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
62 XMesaImage *img = xmesa->xm_buffer->backimage;
64 #define RENDER_SPAN( span ) \
65 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
67 for (i = 0; i < span.end; i++, x++) { \
68 const DEPTH_TYPE z = FixedToDepth(span.z); \
71 PACK_TRUECOLOR(p, FixedToInt(span.red), \
72 FixedToInt(span.green), FixedToInt(span.blue)); \
73 XMesaPutPixel(img, x, y, p); \
76 span.red += span.redStep; \
77 span.green += span.greenStep; \
78 span.blue += span.blueStep; \
79 span.z += span.zStep; \
82 #include "swrast/s_tritemp.h"
88 * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle.
90 #define NAME smooth_8A8B8G8R_z_triangle
92 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
94 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
95 #define PIXEL_TYPE GLuint
96 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
98 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
100 #define RENDER_SPAN( span ) \
102 for (i = 0; i < span.end; i++) { \
103 const DEPTH_TYPE z = FixedToDepth(span.z); \
105 pRow[i] = PACK_8B8G8R(FixedToInt(span.red), \
106 FixedToInt(span.green), FixedToInt(span.blue)); \
109 span.red += span.redStep; \
110 span.green += span.greenStep; \
111 span.blue += span.blueStep; \
112 span.z += span.zStep; \
115 #include "swrast/s_tritemp.h"
120 * XImage, smooth, depth-buffered, PF_8A8R8G8B triangle.
122 #define NAME smooth_8A8R8G8B_z_triangle
124 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
126 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
127 #define PIXEL_TYPE GLuint
128 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
130 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
132 #define RENDER_SPAN( span ) \
134 for (i = 0; i < span.end; i++) { \
135 const DEPTH_TYPE z = FixedToDepth(span.z); \
137 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
138 FixedToInt(span.green), FixedToInt(span.blue)); \
141 span.red += span.redStep; \
142 span.green += span.greenStep; \
143 span.blue += span.blueStep; \
144 span.z += span.zStep; \
147 #include "swrast/s_tritemp.h"
152 * XImage, smooth, depth-buffered, PF_8R8G8B triangle.
154 #define NAME smooth_8R8G8B_z_triangle
156 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
158 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
159 #define PIXEL_TYPE GLuint
160 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
162 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
164 #define RENDER_SPAN( span ) \
166 for (i = 0; i < span.end; i++) { \
167 const DEPTH_TYPE z = FixedToDepth(span.z); \
169 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
170 FixedToInt(span.green), FixedToInt(span.blue)); \
173 span.red += span.redStep; \
174 span.green += span.greenStep; \
175 span.blue += span.blueStep; \
176 span.z += span.zStep; \
179 #include "swrast/s_tritemp.h"
184 * XImage, smooth, depth-buffered, PF_8R8G8B24 triangle.
186 #define NAME smooth_8R8G8B24_z_triangle
188 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
190 #define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
191 #define PIXEL_TYPE bgr_t
192 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
194 XMesaContext xmesa = XMESA_CONTEXT(ctx);
195 #define RENDER_SPAN( span ) \
197 for (i = 0; i < span.end; i++) { \
198 const DEPTH_TYPE z = FixedToDepth(span.z); \
200 PIXEL_TYPE *ptr = pRow + i; \
201 ptr->r = FixedToInt(span.red); \
202 ptr->g = FixedToInt(span.green); \
203 ptr->b = FixedToInt(span.blue); \
206 span.red += span.redStep; \
207 span.green += span.greenStep; \
208 span.blue += span.blueStep; \
209 span.z += span.zStep; \
211 #include "swrast/s_tritemp.h"
216 * XImage, smooth, depth-buffered, PF_TRUEDITHER triangle.
218 #define NAME smooth_TRUEDITHER_z_triangle
220 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
223 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
224 XMesaImage *img = xmesa->xm_buffer->backimage;
225 #define RENDER_SPAN( span ) \
227 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
228 for (i = 0; i < span.end; i++, x++) { \
229 const DEPTH_TYPE z = FixedToDepth(span.z); \
232 PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \
233 FixedToInt(span.green), FixedToInt(span.blue)); \
234 XMesaPutPixel(img, x, y, p); \
237 span.red += span.redStep; \
238 span.green += span.greenStep; \
239 span.blue += span.blueStep; \
240 span.z += span.zStep; \
242 #include "swrast/s_tritemp.h"
247 * XImage, smooth, depth-buffered, PF_5R6G5B triangle.
249 #define NAME smooth_5R6G5B_z_triangle
251 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
253 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
254 #define PIXEL_TYPE GLushort
255 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
257 XMesaContext xmesa = XMESA_CONTEXT(ctx);
258 #define RENDER_SPAN( span ) \
260 for (i = 0; i < span.end; i++) { \
261 const DEPTH_TYPE z = FixedToDepth(span.z); \
263 pRow[i] = PACK_5R6G5B(FixedToInt(span.red), \
264 FixedToInt(span.green), FixedToInt(span.blue)); \
267 span.red += span.redStep; \
268 span.green += span.greenStep; \
269 span.blue += span.blueStep; \
270 span.z += span.zStep; \
272 #include "swrast/s_tritemp.h"
277 * XImage, smooth, depth-buffered, PF_DITHER_5R6G5B triangle.
279 #define NAME smooth_DITHER_5R6G5B_z_triangle
281 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
283 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
284 #define PIXEL_TYPE GLushort
285 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
287 XMesaContext xmesa = XMESA_CONTEXT(ctx);
288 #define RENDER_SPAN( span ) \
290 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
291 for (i = 0; i < span.end; i++, x++) { \
292 const DEPTH_TYPE z = FixedToDepth(span.z); \
294 PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \
295 FixedToInt(span.green), FixedToInt(span.blue)); \
298 span.red += span.redStep; \
299 span.green += span.greenStep; \
300 span.blue += span.blueStep; \
301 span.z += span.zStep; \
303 #include "swrast/s_tritemp.h"
308 * XImage, smooth, depth-buffered, 8-bit, PF_DITHER8 triangle.
310 #define NAME smooth_DITHER8_z_triangle
312 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
314 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
315 #define PIXEL_TYPE GLubyte
316 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
318 XMesaContext xmesa = XMESA_CONTEXT(ctx);
319 #define RENDER_SPAN( span ) \
321 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
323 for (i = 0; i < span.end; i++, x++) { \
324 const DEPTH_TYPE z = FixedToDepth(span.z); \
326 pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red),\
327 FixedToInt(span.green), FixedToInt(span.blue) ); \
330 span.red += span.redStep; \
331 span.green += span.greenStep; \
332 span.blue += span.blueStep; \
333 span.z += span.zStep; \
335 #include "swrast/s_tritemp.h"
340 * XImage, smooth, depth-buffered, PF_DITHER triangle.
342 #define NAME smooth_DITHER_z_triangle
344 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
347 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
348 XMesaImage *img = xmesa->xm_buffer->backimage;
349 #define RENDER_SPAN( span ) \
351 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
353 for (i = 0; i < span.end; i++, x++) { \
354 const DEPTH_TYPE z = FixedToDepth(span.z); \
356 unsigned long p = XDITHER(x, FixedToInt(span.red), \
357 FixedToInt(span.green), FixedToInt(span.blue)); \
358 XMesaPutPixel(img, x, y, p); \
361 span.red += span.redStep; \
362 span.green += span.greenStep; \
363 span.blue += span.blueStep; \
364 span.z += span.zStep; \
366 #include "swrast/s_tritemp.h"
371 * XImage, smooth, depth-buffered, 8-bit PF_LOOKUP triangle.
373 #define NAME smooth_LOOKUP8_z_triangle
375 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
377 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
378 #define PIXEL_TYPE GLubyte
379 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
381 XMesaContext xmesa = XMESA_CONTEXT(ctx);
382 #define RENDER_SPAN( span ) \
385 for (i = 0; i < span.end; i++) { \
386 const DEPTH_TYPE z = FixedToDepth(span.z); \
388 pRow[i] = LOOKUP(FixedToInt(span.red), \
389 FixedToInt(span.green), FixedToInt(span.blue)); \
392 span.red += span.redStep; \
393 span.green += span.greenStep; \
394 span.blue += span.blueStep; \
395 span.z += span.zStep; \
397 #include "swrast/s_tritemp.h"
402 * XImage, smooth, depth-buffered, 8-bit PF_HPCR triangle.
404 #define NAME smooth_HPCR_z_triangle
406 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
408 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
409 #define PIXEL_TYPE GLubyte
410 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
412 XMesaContext xmesa = XMESA_CONTEXT(ctx);
413 #define RENDER_SPAN( span ) \
415 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
416 for (i = 0; i < span.end; i++, x++) { \
417 const DEPTH_TYPE z = FixedToDepth(span.z); \
419 pRow[i] = DITHER_HPCR(x, y, FixedToInt(span.red), \
420 FixedToInt(span.green), FixedToInt(span.blue) ); \
423 span.red += span.redStep; \
424 span.green += span.greenStep; \
425 span.blue += span.blueStep; \
426 span.z += span.zStep; \
428 #include "swrast/s_tritemp.h"
433 * XImage, flat, depth-buffered, PF_TRUECOLOR triangle.
435 #define NAME flat_TRUECOLOR_z_triangle
437 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
439 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
440 XMesaImage *img = xmesa->xm_buffer->backimage; \
441 unsigned long pixel; \
442 PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]);
443 #define RENDER_SPAN( span ) \
445 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
446 for (i = 0; i < span.end; i++, x++) { \
447 const DEPTH_TYPE z = FixedToDepth(span.z); \
449 XMesaPutPixel(img, x, y, pixel); \
452 span.z += span.zStep; \
454 #include "swrast/s_tritemp.h"
459 * XImage, flat, depth-buffered, PF_8A8B8G8R triangle.
461 #define NAME flat_8A8B8G8R_z_triangle
463 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
464 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
465 #define PIXEL_TYPE GLuint
466 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
468 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
469 unsigned long p = PACK_8B8G8R( v2->color[0], \
470 v2->color[1], v2->color[2] );
471 #define RENDER_SPAN( span ) \
473 for (i = 0; i < span.end; i++) { \
474 const DEPTH_TYPE z = FixedToDepth(span.z); \
476 pRow[i] = (PIXEL_TYPE) p; \
479 span.z += span.zStep; \
481 #include "swrast/s_tritemp.h"
486 * XImage, flat, depth-buffered, PF_8A8R8G8B triangle.
488 #define NAME flat_8A8R8G8B_z_triangle
490 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
491 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
492 #define PIXEL_TYPE GLuint
493 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
495 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
496 unsigned long p = PACK_8R8G8B( v2->color[0], \
497 v2->color[1], v2->color[2] );
498 #define RENDER_SPAN( span ) \
500 for (i = 0; i < span.end; i++) { \
501 const DEPTH_TYPE z = FixedToDepth(span.z); \
503 pRow[i] = (PIXEL_TYPE) p; \
506 span.z += span.zStep; \
508 #include "swrast/s_tritemp.h"
513 * XImage, flat, depth-buffered, PF_8R8G8B triangle.
515 #define NAME flat_8R8G8B_z_triangle
517 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
518 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
519 #define PIXEL_TYPE GLuint
520 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
522 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
523 unsigned long p = PACK_8R8G8B( v2->color[0], \
524 v2->color[1], v2->color[2] );
525 #define RENDER_SPAN( span ) \
527 for (i = 0; i < span.end; i++) { \
528 DEPTH_TYPE z = FixedToDepth(span.z); \
530 pRow[i] = (PIXEL_TYPE) p; \
533 span.z += span.zStep; \
535 #include "swrast/s_tritemp.h"
540 * XImage, flat, depth-buffered, PF_8R8G8B24 triangle.
542 #define NAME flat_8R8G8B24_z_triangle
544 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
545 #define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
546 #define PIXEL_TYPE bgr_t
547 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
549 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
550 const GLubyte *color = v2->color;
551 #define RENDER_SPAN( span ) \
553 for (i = 0; i < span.end; i++) { \
554 const DEPTH_TYPE z = FixedToDepth(span.z); \
556 PIXEL_TYPE *ptr = pRow + i; \
557 ptr->r = color[RCOMP]; \
558 ptr->g = color[GCOMP]; \
559 ptr->b = color[BCOMP]; \
562 span.z += span.zStep; \
564 #include "swrast/s_tritemp.h"
569 * XImage, flat, depth-buffered, PF_TRUEDITHER triangle.
571 #define NAME flat_TRUEDITHER_z_triangle
573 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
575 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
576 XMesaImage *img = xmesa->xm_buffer->backimage;
577 #define RENDER_SPAN( span ) \
579 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
580 for (i = 0; i < span.end; i++, x++) { \
581 const DEPTH_TYPE z = FixedToDepth(span.z); \
584 PACK_TRUEDITHER(p, x, y, v2->color[0], \
585 v2->color[1], v2->color[2]); \
586 XMesaPutPixel(img, x, y, p); \
589 span.z += span.zStep; \
591 #include "swrast/s_tritemp.h"
596 * XImage, flat, depth-buffered, PF_5R6G5B triangle.
598 #define NAME flat_5R6G5B_z_triangle
600 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
601 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
602 #define PIXEL_TYPE GLushort
603 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
605 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
606 unsigned long p = PACK_5R6G5B( v2->color[0], \
607 v2->color[1], v2->color[2] );
608 #define RENDER_SPAN( span ) \
610 for (i = 0; i < span.end; i++) { \
611 const DEPTH_TYPE z = FixedToDepth(span.z); \
613 pRow[i] = (PIXEL_TYPE) p; \
616 span.z += span.zStep; \
618 #include "swrast/s_tritemp.h"
623 * XImage, flat, depth-buffered, PF_DITHER_5R6G5B triangle.
625 #define NAME flat_DITHER_5R6G5B_z_triangle
627 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
628 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
629 #define PIXEL_TYPE GLushort
630 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
632 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
633 const GLubyte *color = v2->color;
634 #define RENDER_SPAN( span ) \
636 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
637 for (i = 0; i < span.end; i++, x++) { \
638 const DEPTH_TYPE z = FixedToDepth(span.z); \
640 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \
641 color[GCOMP], color[BCOMP]); \
644 span.z += span.zStep; \
646 #include "swrast/s_tritemp.h"
651 * XImage, flat, depth-buffered, 8-bit PF_DITHER triangle.
653 #define NAME flat_DITHER8_z_triangle
655 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
656 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
657 #define PIXEL_TYPE GLubyte
658 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
660 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
661 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
662 #define RENDER_SPAN( span ) \
664 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
665 FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, y)); \
666 for (i = 0; i < span.end; i++, x++) { \
667 const DEPTH_TYPE z = FixedToDepth(span.z); \
669 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x); \
672 span.z += span.zStep; \
674 #include "swrast/s_tritemp.h"
679 * XImage, flat, depth-buffered, PF_DITHER triangle.
681 #define NAME flat_DITHER_z_triangle
683 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
685 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
686 XMesaImage *img = xmesa->xm_buffer->backimage; \
687 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
688 #define RENDER_SPAN( span ) \
690 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
691 FLAT_DITHER_ROW_SETUP(y); \
692 for (i = 0; i < span.end; i++, x++) { \
693 const DEPTH_TYPE z = FixedToDepth(span.z); \
695 unsigned long p = FLAT_DITHER(x); \
696 XMesaPutPixel(img, x, y, p); \
699 span.z += span.zStep; \
701 #include "swrast/s_tritemp.h"
706 * XImage, flat, depth-buffered, 8-bit PF_HPCR triangle.
708 #define NAME flat_HPCR_z_triangle
710 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
711 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
712 #define PIXEL_TYPE GLubyte
713 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
715 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
716 GLubyte r = v2->color[0]; \
717 GLubyte g = v2->color[1]; \
718 GLubyte b = v2->color[2];
719 #define RENDER_SPAN( span ) \
721 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
722 for (i = 0; i < span.end; i++, x++) { \
723 const DEPTH_TYPE z = FixedToDepth(span.z); \
725 pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b); \
728 span.z += span.zStep; \
730 #include "swrast/s_tritemp.h"
735 * XImage, flat, depth-buffered, 8-bit PF_LOOKUP triangle.
737 #define NAME flat_LOOKUP8_z_triangle
739 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
740 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
741 #define PIXEL_TYPE GLubyte
742 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
744 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
746 GLubyte r = v2->color[0]; \
747 GLubyte g = v2->color[1]; \
748 GLubyte b = v2->color[2]; \
749 GLubyte p = LOOKUP(r,g,b);
750 #define RENDER_SPAN( span ) \
752 for (i = 0; i < span.end; i++) { \
753 const DEPTH_TYPE z = FixedToDepth(span.z); \
758 span.z += span.zStep; \
760 #include "swrast/s_tritemp.h"
765 * XImage, smooth, NON-depth-buffered, PF_TRUECOLOR triangle.
767 #define NAME smooth_TRUECOLOR_triangle
770 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
771 XMesaImage *img = xmesa->xm_buffer->backimage;
772 #define RENDER_SPAN( span ) \
774 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
775 for (i = 0; i < span.end; i++, x++) { \
777 PACK_TRUECOLOR(p, FixedToInt(span.red), \
778 FixedToInt(span.green), FixedToInt(span.blue)); \
779 XMesaPutPixel(img, x, y, p); \
780 span.red += span.redStep; \
781 span.green += span.greenStep; \
782 span.blue += span.blueStep; \
784 #include "swrast/s_tritemp.h"
789 * XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle.
791 #define NAME smooth_8A8B8G8R_triangle
793 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
794 #define PIXEL_TYPE GLuint
795 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
797 XMesaContext xmesa = XMESA_CONTEXT(ctx);
798 #define RENDER_SPAN( span ) \
800 for (i = 0; i < span.end; i++) { \
801 pRow[i] = PACK_8B8G8R(FixedToInt(span.red), \
802 FixedToInt(span.green), FixedToInt(span.blue) ); \
803 span.red += span.redStep; \
804 span.green += span.greenStep; \
805 span.blue += span.blueStep; \
807 #include "swrast/s_tritemp.h"
812 * XImage, smooth, NON-depth-buffered, PF_8A8R8G8B triangle.
814 #define NAME smooth_8A8R8G8B_triangle
816 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
817 #define PIXEL_TYPE GLuint
818 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
820 XMesaContext xmesa = XMESA_CONTEXT(ctx);
821 #define RENDER_SPAN( span ) \
823 for (i = 0; i < span.end; i++) { \
824 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
825 FixedToInt(span.green), FixedToInt(span.blue) ); \
826 span.red += span.redStep; \
827 span.green += span.greenStep; \
828 span.blue += span.blueStep; \
830 #include "swrast/s_tritemp.h"
835 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
837 #define NAME smooth_8R8G8B_triangle
839 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
840 #define PIXEL_TYPE GLuint
841 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
843 XMesaContext xmesa = XMESA_CONTEXT(ctx);
844 #define RENDER_SPAN( span ) \
846 for (i = 0; i < span.end; i++) { \
847 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
848 FixedToInt(span.green), FixedToInt(span.blue) ); \
849 span.red += span.redStep; \
850 span.green += span.greenStep; \
851 span.blue += span.blueStep; \
853 #include "swrast/s_tritemp.h"
858 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
860 #define NAME smooth_8R8G8B24_triangle
862 #define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
863 #define PIXEL_TYPE bgr_t
864 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
866 XMesaContext xmesa = XMESA_CONTEXT(ctx);
867 #define RENDER_SPAN( span ) \
869 PIXEL_TYPE *pixel = pRow; \
870 for (i = 0; i < span.end; i++, pixel++) { \
871 pixel->r = FixedToInt(span.red); \
872 pixel->g = FixedToInt(span.green); \
873 pixel->b = FixedToInt(span.blue); \
874 span.red += span.redStep; \
875 span.green += span.greenStep; \
876 span.blue += span.blueStep; \
878 #include "swrast/s_tritemp.h"
883 * XImage, smooth, NON-depth-buffered, PF_TRUEDITHER triangle.
885 #define NAME smooth_TRUEDITHER_triangle
888 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
889 XMesaImage *img = xmesa->xm_buffer->backimage;
890 #define RENDER_SPAN( span ) \
892 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
893 for (i = 0; i < span.end; i++, x++) { \
895 PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \
896 FixedToInt(span.green), FixedToInt(span.blue)); \
897 XMesaPutPixel(img, x, y, p ); \
898 span.red += span.redStep; \
899 span.green += span.greenStep; \
900 span.blue += span.blueStep; \
902 #include "swrast/s_tritemp.h"
907 * XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle.
909 #define NAME smooth_5R6G5B_triangle
911 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
912 #define PIXEL_TYPE GLushort
913 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
915 XMesaContext xmesa = XMESA_CONTEXT(ctx);
916 #define RENDER_SPAN( span ) \
918 for (i = 0; i < span.end; i++) { \
919 pRow[i] = (PIXEL_TYPE) PACK_5R6G5B(FixedToInt(span.red), \
920 FixedToInt(span.green), FixedToInt(span.blue)); \
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_DITHER_5R6G5B triangle.
932 #define NAME smooth_DITHER_5R6G5B_triangle
934 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
935 #define PIXEL_TYPE GLushort
936 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
938 XMesaContext xmesa = XMESA_CONTEXT(ctx);
939 #define RENDER_SPAN( span ) \
941 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
942 for (i = 0; i < span.end; i++, x++) { \
943 PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \
944 FixedToInt(span.green), FixedToInt(span.blue)); \
945 span.red += span.redStep; \
946 span.green += span.greenStep; \
947 span.blue += span.blueStep; \
949 #include "swrast/s_tritemp.h"
954 * XImage, smooth, NON-depth-buffered, 8-bit PF_DITHER triangle.
956 #define NAME smooth_DITHER8_triangle
958 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
959 #define PIXEL_TYPE GLubyte
960 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
962 XMesaContext xmesa = XMESA_CONTEXT(ctx);
963 #define RENDER_SPAN( span ) \
965 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
967 for (i = 0; i < span.end; i++, x++) { \
968 pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red), \
969 FixedToInt(span.green), FixedToInt(span.blue) ); \
970 span.red += span.redStep; \
971 span.green += span.greenStep; \
972 span.blue += span.blueStep; \
974 #include "swrast/s_tritemp.h"
979 * XImage, smooth, NON-depth-buffered, PF_DITHER triangle.
981 #define NAME smooth_DITHER_triangle
984 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
985 XMesaImage *img = xmesa->xm_buffer->backimage;
986 #define RENDER_SPAN( span ) \
988 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
990 for (i = 0; i < span.end; i++, x++) { \
991 unsigned long p = XDITHER(x, FixedToInt(span.red), \
992 FixedToInt(span.green), FixedToInt(span.blue) ); \
993 XMesaPutPixel(img, x, y, p); \
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, 8-bit PF_LOOKUP triangle.
1005 #define NAME smooth_LOOKUP8_triangle
1006 #define INTERP_RGB 1
1007 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
1008 #define PIXEL_TYPE GLubyte
1009 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1010 #define SETUP_CODE \
1011 XMesaContext xmesa = XMESA_CONTEXT(ctx);
1012 #define RENDER_SPAN( span ) \
1015 for (i = 0; i < span.end; i++) { \
1016 pRow[i] = LOOKUP(FixedToInt(span.red), \
1017 FixedToInt(span.green), FixedToInt(span.blue)); \
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_HPCR triangle.
1029 #define NAME smooth_HPCR_triangle
1030 #define INTERP_RGB 1
1031 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
1032 #define PIXEL_TYPE GLubyte
1033 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1034 #define SETUP_CODE \
1035 XMesaContext xmesa = XMESA_CONTEXT(ctx);
1036 #define RENDER_SPAN( span ) \
1038 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
1039 for (i = 0; i < span.end; i++, x++) { \
1040 pRow[i] = DITHER_HPCR(x, y, 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, flat, NON-depth-buffered, PF_TRUECOLOR triangle.
1053 #define NAME flat_TRUECOLOR_triangle
1054 #define SETUP_CODE \
1055 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1056 XMesaImage *img = xmesa->xm_buffer->backimage; \
1057 unsigned long pixel; \
1058 PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]);
1059 #define RENDER_SPAN( span ) \
1061 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
1062 for (i = 0; i < span.end; i++, x++) { \
1063 XMesaPutPixel(img, x, y, pixel); \
1065 #include "swrast/s_tritemp.h"
1070 * XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle.
1072 #define NAME flat_8A8B8G8R_triangle
1073 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
1074 #define PIXEL_TYPE GLuint
1075 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1076 #define SETUP_CODE \
1077 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1078 unsigned long p = PACK_8B8G8R( v2->color[0], \
1079 v2->color[1], v2->color[2] );
1080 #define RENDER_SPAN( span ) \
1082 for (i = 0; i < span.end; i++) { \
1083 pRow[i] = (PIXEL_TYPE) p; \
1085 #include "swrast/s_tritemp.h"
1090 * XImage, flat, NON-depth-buffered, PF_8A8R8G8B triangle.
1092 #define NAME flat_8A8R8G8B_triangle
1093 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
1094 #define PIXEL_TYPE GLuint
1095 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1096 #define SETUP_CODE \
1097 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1098 unsigned long p = PACK_8R8G8B( v2->color[0], \
1099 v2->color[1], v2->color[2] );
1100 #define RENDER_SPAN( span ) \
1102 for (i = 0; i < span.end; i++) { \
1103 pRow[i] = (PIXEL_TYPE) p; \
1105 #include "swrast/s_tritemp.h"
1110 * XImage, flat, NON-depth-buffered, PF_8R8G8B triangle.
1112 #define NAME flat_8R8G8B_triangle
1113 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
1114 #define PIXEL_TYPE GLuint
1115 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1116 #define SETUP_CODE \
1117 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1118 unsigned long p = PACK_8R8G8B( v2->color[0], \
1119 v2->color[1], v2->color[2] );
1120 #define RENDER_SPAN( span ) \
1122 for (i = 0; i < span.end; i++) { \
1123 pRow[i] = (PIXEL_TYPE) p; \
1125 #include "swrast/s_tritemp.h"
1130 * XImage, flat, NON-depth-buffered, PF_8R8G8B24 triangle.
1132 #define NAME flat_8R8G8B24_triangle
1133 #define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
1134 #define PIXEL_TYPE bgr_t
1135 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1136 #define SETUP_CODE \
1137 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1138 const GLubyte *color = v2->color;
1139 #define RENDER_SPAN( span ) \
1141 PIXEL_TYPE *pixel = pRow; \
1142 for (i = 0; i < span.end; i++, pixel++) { \
1143 pixel->r = color[RCOMP]; \
1144 pixel->g = color[GCOMP]; \
1145 pixel->b = color[BCOMP]; \
1147 #include "swrast/s_tritemp.h"
1152 * XImage, flat, NON-depth-buffered, PF_TRUEDITHER triangle.
1154 #define NAME flat_TRUEDITHER_triangle
1155 #define SETUP_CODE \
1156 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1157 XMesaImage *img = xmesa->xm_buffer->backimage;
1158 #define RENDER_SPAN( span ) \
1160 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
1161 for (i = 0; i < span.end; i++, x++) { \
1163 PACK_TRUEDITHER(p, x, y, v2->color[0], \
1164 v2->color[1], v2->color[2] ); \
1165 XMesaPutPixel(img, x, y, p); \
1167 #include "swrast/s_tritemp.h"
1172 * XImage, flat, NON-depth-buffered, PF_5R6G5B triangle.
1174 #define NAME flat_5R6G5B_triangle
1175 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
1176 #define PIXEL_TYPE GLushort
1177 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1178 #define SETUP_CODE \
1179 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1180 unsigned long p = PACK_5R6G5B( v2->color[0], \
1181 v2->color[1], v2->color[2] );
1182 #define RENDER_SPAN( span ) \
1184 for (i = 0; i < span.end; i++) { \
1185 pRow[i] = (PIXEL_TYPE) p; \
1187 #include "swrast/s_tritemp.h"
1192 * XImage, flat, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
1194 #define NAME flat_DITHER_5R6G5B_triangle
1195 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
1196 #define PIXEL_TYPE GLushort
1197 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1198 #define SETUP_CODE \
1199 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1200 const GLubyte *color = v2->color;
1201 #define RENDER_SPAN( span ) \
1203 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
1204 for (i = 0; i < span.end; i++, x++) { \
1205 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \
1206 color[GCOMP], color[BCOMP]); \
1208 #include "swrast/s_tritemp.h"
1213 * XImage, flat, NON-depth-buffered, 8-bit PF_DITHER triangle.
1215 #define NAME flat_DITHER8_triangle
1216 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
1217 #define PIXEL_TYPE GLubyte
1218 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1219 #define SETUP_CODE \
1220 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1221 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
1222 #define RENDER_SPAN( span ) \
1224 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
1225 FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, y)); \
1226 for (i = 0; i < span.end; i++, x++) { \
1227 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x); \
1229 #include "swrast/s_tritemp.h"
1234 * XImage, flat, NON-depth-buffered, PF_DITHER triangle.
1236 #define NAME flat_DITHER_triangle
1237 #define SETUP_CODE \
1238 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1239 XMesaImage *img = xmesa->xm_buffer->backimage; \
1240 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
1241 #define RENDER_SPAN( span ) \
1243 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
1244 FLAT_DITHER_ROW_SETUP(y); \
1245 for (i = 0; i < span.end; i++, x++) { \
1246 unsigned long p = FLAT_DITHER(x); \
1247 XMesaPutPixel(img, x, y, p ); \
1249 #include "swrast/s_tritemp.h"
1254 * XImage, flat, NON-depth-buffered, 8-bit PF_HPCR triangle.
1256 #define NAME flat_HPCR_triangle
1257 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
1258 #define PIXEL_TYPE GLubyte
1259 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1260 #define SETUP_CODE \
1261 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1262 GLubyte r = v2->color[0]; \
1263 GLubyte g = v2->color[1]; \
1264 GLubyte b = v2->color[2];
1265 #define RENDER_SPAN( span ) \
1267 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
1268 for (i = 0; i < span.end; i++, x++) { \
1269 pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b); \
1271 #include "swrast/s_tritemp.h"
1276 * XImage, flat, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
1278 #define NAME flat_LOOKUP8_triangle
1279 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
1280 #define PIXEL_TYPE GLubyte
1281 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1282 #define SETUP_CODE \
1283 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1285 GLubyte r = v2->color[0]; \
1286 GLubyte g = v2->color[1]; \
1287 GLubyte b = v2->color[2]; \
1288 GLubyte p = LOOKUP(r,g,b);
1289 #define RENDER_SPAN( span ) \
1291 for (i = 0; i < span.end; i++) { \
1292 pRow[i] = (PIXEL_TYPE) p; \
1294 #include "swrast/s_tritemp.h"
1299 extern void _xmesa_print_triangle_func( swrast_tri_func triFunc
);
1300 void _xmesa_print_triangle_func( swrast_tri_func triFunc
)
1302 _mesa_printf("XMesa tri func = ");
1303 if (triFunc
==smooth_TRUECOLOR_z_triangle
)
1304 _mesa_printf("smooth_TRUECOLOR_z_triangle\n");
1305 else if (triFunc
==smooth_8A8B8G8R_z_triangle
)
1306 _mesa_printf("smooth_8A8B8G8R_z_triangle\n");
1307 else if (triFunc
==smooth_8A8R8G8B_z_triangle
)
1308 _mesa_printf("smooth_8A8R8G8B_z_triangle\n");
1309 else if (triFunc
==smooth_8R8G8B_z_triangle
)
1310 _mesa_printf("smooth_8R8G8B_z_triangle\n");
1311 else if (triFunc
==smooth_8R8G8B24_z_triangle
)
1312 _mesa_printf("smooth_8R8G8B24_z_triangle\n");
1313 else if (triFunc
==smooth_TRUEDITHER_z_triangle
)
1314 _mesa_printf("smooth_TRUEDITHER_z_triangle\n");
1315 else if (triFunc
==smooth_5R6G5B_z_triangle
)
1316 _mesa_printf("smooth_5R6G5B_z_triangle\n");
1317 else if (triFunc
==smooth_DITHER_5R6G5B_z_triangle
)
1318 _mesa_printf("smooth_DITHER_5R6G5B_z_triangle\n");
1319 else if (triFunc
==smooth_HPCR_z_triangle
)
1320 _mesa_printf("smooth_HPCR_z_triangle\n");
1321 else if (triFunc
==smooth_DITHER8_z_triangle
)
1322 _mesa_printf("smooth_DITHER8_z_triangle\n");
1323 else if (triFunc
==smooth_LOOKUP8_z_triangle
)
1324 _mesa_printf("smooth_LOOKUP8_z_triangle\n");
1325 else if (triFunc
==flat_TRUECOLOR_z_triangle
)
1326 _mesa_printf("flat_TRUECOLOR_z_triangle\n");
1327 else if (triFunc
==flat_8A8B8G8R_z_triangle
)
1328 _mesa_printf("flat_8A8B8G8R_z_triangle\n");
1329 else if (triFunc
==flat_8A8R8G8B_z_triangle
)
1330 _mesa_printf("flat_8A8R8G8B_z_triangle\n");
1331 else if (triFunc
==flat_8R8G8B_z_triangle
)
1332 _mesa_printf("flat_8R8G8B_z_triangle\n");
1333 else if (triFunc
==flat_8R8G8B24_z_triangle
)
1334 _mesa_printf("flat_8R8G8B24_z_triangle\n");
1335 else if (triFunc
==flat_TRUEDITHER_z_triangle
)
1336 _mesa_printf("flat_TRUEDITHER_z_triangle\n");
1337 else if (triFunc
==flat_5R6G5B_z_triangle
)
1338 _mesa_printf("flat_5R6G5B_z_triangle\n");
1339 else if (triFunc
==flat_DITHER_5R6G5B_z_triangle
)
1340 _mesa_printf("flat_DITHER_5R6G5B_z_triangle\n");
1341 else if (triFunc
==flat_HPCR_z_triangle
)
1342 _mesa_printf("flat_HPCR_z_triangle\n");
1343 else if (triFunc
==flat_DITHER8_z_triangle
)
1344 _mesa_printf("flat_DITHER8_z_triangle\n");
1345 else if (triFunc
==flat_LOOKUP8_z_triangle
)
1346 _mesa_printf("flat_LOOKUP8_z_triangle\n");
1347 else if (triFunc
==smooth_TRUECOLOR_triangle
)
1348 _mesa_printf("smooth_TRUECOLOR_triangle\n");
1349 else if (triFunc
==smooth_8A8B8G8R_triangle
)
1350 _mesa_printf("smooth_8A8B8G8R_triangle\n");
1351 else if (triFunc
==smooth_8A8R8G8B_triangle
)
1352 _mesa_printf("smooth_8A8R8G8B_triangle\n");
1353 else if (triFunc
==smooth_8R8G8B_triangle
)
1354 _mesa_printf("smooth_8R8G8B_triangle\n");
1355 else if (triFunc
==smooth_8R8G8B24_triangle
)
1356 _mesa_printf("smooth_8R8G8B24_triangle\n");
1357 else if (triFunc
==smooth_TRUEDITHER_triangle
)
1358 _mesa_printf("smooth_TRUEDITHER_triangle\n");
1359 else if (triFunc
==smooth_5R6G5B_triangle
)
1360 _mesa_printf("smooth_5R6G5B_triangle\n");
1361 else if (triFunc
==smooth_DITHER_5R6G5B_triangle
)
1362 _mesa_printf("smooth_DITHER_5R6G5B_triangle\n");
1363 else if (triFunc
==smooth_HPCR_triangle
)
1364 _mesa_printf("smooth_HPCR_triangle\n");
1365 else if (triFunc
==smooth_DITHER8_triangle
)
1366 _mesa_printf("smooth_DITHER8_triangle\n");
1367 else if (triFunc
==smooth_LOOKUP8_triangle
)
1368 _mesa_printf("smooth_LOOKUP8_triangle\n");
1369 else if (triFunc
==flat_TRUECOLOR_triangle
)
1370 _mesa_printf("flat_TRUECOLOR_triangle\n");
1371 else if (triFunc
==flat_TRUEDITHER_triangle
)
1372 _mesa_printf("flat_TRUEDITHER_triangle\n");
1373 else if (triFunc
==flat_8A8B8G8R_triangle
)
1374 _mesa_printf("flat_8A8B8G8R_triangle\n");
1375 else if (triFunc
==flat_8A8R8G8B_triangle
)
1376 _mesa_printf("flat_8A8R8G8B_triangle\n");
1377 else if (triFunc
==flat_8R8G8B_triangle
)
1378 _mesa_printf("flat_8R8G8B_triangle\n");
1379 else if (triFunc
==flat_8R8G8B24_triangle
)
1380 _mesa_printf("flat_8R8G8B24_triangle\n");
1381 else if (triFunc
==flat_5R6G5B_triangle
)
1382 _mesa_printf("flat_5R6G5B_triangle\n");
1383 else if (triFunc
==flat_DITHER_5R6G5B_triangle
)
1384 _mesa_printf("flat_DITHER_5R6G5B_triangle\n");
1385 else if (triFunc
==flat_HPCR_triangle
)
1386 _mesa_printf("flat_HPCR_triangle\n");
1387 else if (triFunc
==flat_DITHER8_triangle
)
1388 _mesa_printf("flat_DITHER8_triangle\n");
1389 else if (triFunc
==flat_LOOKUP8_triangle
)
1390 _mesa_printf("flat_LOOKUP8_triangle\n");
1392 _mesa_printf("???\n");
1399 /* record the current triangle function name */
1400 static const char *triFuncName
= NULL
;
1402 #define USE(triFunc) \
1404 triFuncName = #triFunc; \
1410 #define USE(triFunc) return triFunc
1415 static swrast_tri_func
get_triangle_func( GLcontext
*ctx
)
1417 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
1418 XMesaContext xmesa
= XMESA_CONTEXT(ctx
);
1419 int depth
= GET_VISUAL_DEPTH(xmesa
->xm_visual
);
1425 if ((ctx
->Color
._DrawDestMask
[0] & (DD_FRONT_LEFT_BIT
| DD_BACK_LEFT_BIT
)) ==0)
1426 return (swrast_tri_func
) NULL
;
1427 if (ctx
->RenderMode
!= GL_RENDER
) return (swrast_tri_func
) NULL
;
1428 if (ctx
->Polygon
.SmoothFlag
) return (swrast_tri_func
) NULL
;
1429 if (ctx
->Texture
._EnabledUnits
) return (swrast_tri_func
) NULL
;
1430 if (swrast
->_RasterMask
& MULTI_DRAW_BIT
) return (swrast_tri_func
) NULL
;
1431 if (ctx
->Polygon
.CullFlag
&&
1432 ctx
->Polygon
.CullFaceMode
== GL_FRONT_AND_BACK
)
1433 return (swrast_tri_func
) NULL
;
1435 if (xmesa
->xm_buffer
->buffer
==XIMAGE
) {
1436 if ( ctx
->Light
.ShadeModel
==GL_SMOOTH
1437 && swrast
->_RasterMask
==DEPTH_BIT
1438 && ctx
->Depth
.Func
==GL_LESS
1439 && ctx
->Depth
.Mask
==GL_TRUE
1440 && ctx
->Visual
.depthBits
== DEFAULT_SOFTWARE_DEPTH_BITS
1441 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1442 switch (xmesa
->pixelformat
) {
1444 USE(smooth_TRUECOLOR_z_triangle
);
1446 USE(smooth_8A8B8G8R_z_triangle
);
1448 USE(smooth_8A8R8G8B_z_triangle
);
1450 USE(smooth_8R8G8B_z_triangle
);
1452 USE(smooth_8R8G8B24_z_triangle
);
1453 case PF_Dither_True
:
1454 USE(smooth_TRUEDITHER_z_triangle
);
1456 USE(smooth_5R6G5B_z_triangle
);
1457 case PF_Dither_5R6G5B
:
1458 USE(smooth_DITHER_5R6G5B_z_triangle
);
1460 USE(smooth_HPCR_z_triangle
);
1463 USE(smooth_DITHER8_z_triangle
);
1465 USE(smooth_DITHER_z_triangle
);
1468 USE(smooth_LOOKUP8_z_triangle
);
1470 return (swrast_tri_func
) NULL
;
1472 return (swrast_tri_func
) NULL
;
1475 if ( ctx
->Light
.ShadeModel
==GL_FLAT
1476 && swrast
->_RasterMask
==DEPTH_BIT
1477 && ctx
->Depth
.Func
==GL_LESS
1478 && ctx
->Depth
.Mask
==GL_TRUE
1479 && ctx
->Visual
.depthBits
== DEFAULT_SOFTWARE_DEPTH_BITS
1480 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1481 switch (xmesa
->pixelformat
) {
1483 USE(flat_TRUECOLOR_z_triangle
);
1485 USE(flat_8A8B8G8R_z_triangle
);
1487 USE(flat_8A8R8G8B_z_triangle
);
1489 USE(flat_8R8G8B_z_triangle
);
1491 USE(flat_8R8G8B24_z_triangle
);
1492 case PF_Dither_True
:
1493 USE(flat_TRUEDITHER_z_triangle
);
1495 USE(flat_5R6G5B_z_triangle
);
1496 case PF_Dither_5R6G5B
:
1497 USE(flat_DITHER_5R6G5B_z_triangle
);
1499 USE(flat_HPCR_z_triangle
);
1502 USE(flat_DITHER8_z_triangle
);
1504 USE(flat_DITHER_z_triangle
);
1507 USE(flat_LOOKUP8_z_triangle
);
1509 return (swrast_tri_func
) NULL
;
1511 return (swrast_tri_func
) NULL
;
1514 if ( swrast
->_RasterMask
==0 /* no depth test */
1515 && ctx
->Light
.ShadeModel
==GL_SMOOTH
1516 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1517 switch (xmesa
->pixelformat
) {
1519 USE(smooth_TRUECOLOR_triangle
);
1521 USE(smooth_8A8B8G8R_triangle
);
1523 USE(smooth_8A8R8G8B_triangle
);
1525 USE(smooth_8R8G8B_triangle
);
1527 USE(smooth_8R8G8B24_triangle
);
1528 case PF_Dither_True
:
1529 USE(smooth_TRUEDITHER_triangle
);
1531 USE(smooth_5R6G5B_triangle
);
1532 case PF_Dither_5R6G5B
:
1533 USE(smooth_DITHER_5R6G5B_triangle
);
1535 USE(smooth_HPCR_triangle
);
1538 USE(smooth_DITHER8_triangle
);
1540 USE(smooth_DITHER_triangle
);
1543 USE(smooth_LOOKUP8_triangle
);
1545 return (swrast_tri_func
) NULL
;
1547 return (swrast_tri_func
) NULL
;
1551 if ( swrast
->_RasterMask
==0 /* no depth test */
1552 && ctx
->Light
.ShadeModel
==GL_FLAT
1553 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1554 switch (xmesa
->pixelformat
) {
1556 USE(flat_TRUECOLOR_triangle
);
1557 case PF_Dither_True
:
1558 USE(flat_TRUEDITHER_triangle
);
1560 USE(flat_8A8B8G8R_triangle
);
1562 USE(flat_8A8R8G8B_triangle
);
1564 USE(flat_8R8G8B_triangle
);
1566 USE(flat_8R8G8B24_triangle
);
1568 USE(flat_5R6G5B_triangle
);
1569 case PF_Dither_5R6G5B
:
1570 USE(flat_DITHER_5R6G5B_triangle
);
1572 USE(flat_HPCR_triangle
);
1575 USE(flat_DITHER8_triangle
);
1577 USE(flat_DITHER_triangle
);
1580 USE(flat_LOOKUP8_triangle
);
1582 return (swrast_tri_func
) NULL
;
1584 return (swrast_tri_func
) NULL
;
1588 return (swrast_tri_func
) NULL
;
1591 /* draw to pixmap */
1592 return (swrast_tri_func
) NULL
;
1597 /* Override for the swrast tri-selection function. Try to use one
1598 * of our internal tri functions, otherwise fall back to the
1599 * standard swrast functions.
1601 void xmesa_choose_triangle( GLcontext
*ctx
)
1603 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
1605 if (!(swrast
->Triangle
= get_triangle_func( ctx
)))
1606 _swrast_choose_triangle( ctx
);