3 * Mesa 3-D graphics library
6 * Copyright (C) 1999-2002 Brian Paul All Rights Reserved.
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
15 * The above copyright notice and this permission notice shall be included
16 * in all copies or substantial portions of the Software.
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
22 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
28 * This file contains "accelerated" triangle functions. It should be
29 * fairly easy to write new special-purpose triangle functions and hook
30 * them into this module.
34 #include "glxheader.h"
41 /* Internal swrast includes:
43 #include "swrast/s_context.h"
44 #include "swrast/s_depth.h"
45 #include "swrast/s_triangle.h"
49 /**********************************************************************/
50 /*** Triangle rendering ***/
51 /**********************************************************************/
55 * XImage, smooth, depth-buffered, PF_TRUECOLOR triangle.
57 #define NAME smooth_TRUECOLOR_z_triangle
59 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
62 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
63 XMesaImage *img = xmesa->xm_buffer->backimage;
65 #define RENDER_SPAN( span ) \
66 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
68 for (i = 0; i < span.end; i++, x++) { \
69 const DEPTH_TYPE z = FixedToDepth(span.z); \
72 PACK_TRUECOLOR(p, FixedToInt(span.red), \
73 FixedToInt(span.green), FixedToInt(span.blue)); \
74 XMesaPutPixel(img, x, y, p); \
77 span.red += span.redStep; \
78 span.green += span.greenStep; \
79 span.blue += span.blueStep; \
80 span.z += span.zStep; \
83 #include "swrast/s_tritemp.h"
89 * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle.
91 #define NAME smooth_8A8B8G8R_z_triangle
93 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
95 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
96 #define PIXEL_TYPE GLuint
97 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
99 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
101 #define RENDER_SPAN( span ) \
103 for (i = 0; i < span.end; i++) { \
104 const DEPTH_TYPE z = FixedToDepth(span.z); \
106 pRow[i] = PACK_8B8G8R(FixedToInt(span.red), \
107 FixedToInt(span.green), FixedToInt(span.blue)); \
110 span.red += span.redStep; \
111 span.green += span.greenStep; \
112 span.blue += span.blueStep; \
113 span.z += span.zStep; \
116 #include "swrast/s_tritemp.h"
121 * XImage, smooth, depth-buffered, PF_8R8G8B triangle.
123 #define NAME smooth_8R8G8B_z_triangle
125 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
127 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
128 #define PIXEL_TYPE GLuint
129 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
131 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
133 #define RENDER_SPAN( span ) \
135 for (i = 0; i < span.end; i++) { \
136 const DEPTH_TYPE z = FixedToDepth(span.z); \
138 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
139 FixedToInt(span.green), FixedToInt(span.blue)); \
142 span.red += span.redStep; \
143 span.green += span.greenStep; \
144 span.blue += span.blueStep; \
145 span.z += span.zStep; \
148 #include "swrast/s_tritemp.h"
153 * XImage, smooth, depth-buffered, PF_8R8G8B24 triangle.
155 #define NAME smooth_8R8G8B24_z_triangle
157 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
159 #define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
160 #define PIXEL_TYPE bgr_t
161 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
163 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 PIXEL_TYPE *ptr = pRow + i; \
170 ptr->r = FixedToInt(span.red); \
171 ptr->g = FixedToInt(span.green); \
172 ptr->b = FixedToInt(span.blue); \
175 span.red += span.redStep; \
176 span.green += span.greenStep; \
177 span.blue += span.blueStep; \
178 span.z += span.zStep; \
180 #include "swrast/s_tritemp.h"
185 * XImage, smooth, depth-buffered, PF_TRUEDITHER triangle.
187 #define NAME smooth_TRUEDITHER_z_triangle
189 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
192 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
193 XMesaImage *img = xmesa->xm_buffer->backimage;
194 #define RENDER_SPAN( span ) \
196 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
197 for (i = 0; i < span.end; i++, x++) { \
198 const DEPTH_TYPE z = FixedToDepth(span.z); \
201 PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \
202 FixedToInt(span.green), FixedToInt(span.blue)); \
203 XMesaPutPixel(img, x, y, p); \
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_5R6G5B triangle.
218 #define NAME smooth_5R6G5B_z_triangle
220 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
222 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
223 #define PIXEL_TYPE GLushort
224 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
226 XMesaContext xmesa = XMESA_CONTEXT(ctx);
227 #define RENDER_SPAN( span ) \
229 for (i = 0; i < span.end; i++) { \
230 const DEPTH_TYPE z = FixedToDepth(span.z); \
232 pRow[i] = PACK_5R6G5B(FixedToInt(span.red), \
233 FixedToInt(span.green), FixedToInt(span.blue)); \
236 span.red += span.redStep; \
237 span.green += span.greenStep; \
238 span.blue += span.blueStep; \
239 span.z += span.zStep; \
241 #include "swrast/s_tritemp.h"
246 * XImage, smooth, depth-buffered, PF_DITHER_5R6G5B triangle.
248 #define NAME smooth_DITHER_5R6G5B_z_triangle
250 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
252 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
253 #define PIXEL_TYPE GLushort
254 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
256 XMesaContext xmesa = XMESA_CONTEXT(ctx);
257 #define RENDER_SPAN( span ) \
259 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
260 for (i = 0; i < span.end; i++, x++) { \
261 const DEPTH_TYPE z = FixedToDepth(span.z); \
263 PACK_TRUEDITHER(pRow[i], x, y, 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, 8-bit, PF_DITHER8 triangle.
279 #define NAME smooth_DITHER8_z_triangle
281 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
283 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
284 #define PIXEL_TYPE GLubyte
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); \
292 for (i = 0; i < span.end; i++, x++) { \
293 const DEPTH_TYPE z = FixedToDepth(span.z); \
295 pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red),\
296 FixedToInt(span.green), FixedToInt(span.blue) ); \
299 span.red += span.redStep; \
300 span.green += span.greenStep; \
301 span.blue += span.blueStep; \
302 span.z += span.zStep; \
304 #include "swrast/s_tritemp.h"
309 * XImage, smooth, depth-buffered, PF_DITHER triangle.
311 #define NAME smooth_DITHER_z_triangle
313 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
316 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
317 XMesaImage *img = xmesa->xm_buffer->backimage;
318 #define RENDER_SPAN( span ) \
320 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
322 for (i = 0; i < span.end; i++, x++) { \
323 const DEPTH_TYPE z = FixedToDepth(span.z); \
325 unsigned long p = XDITHER(x, FixedToInt(span.red), \
326 FixedToInt(span.green), FixedToInt(span.blue)); \
327 XMesaPutPixel(img, x, y, p); \
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, 8-bit PF_LOOKUP triangle.
342 #define NAME smooth_LOOKUP8_z_triangle
344 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
346 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
347 #define PIXEL_TYPE GLubyte
348 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
350 XMesaContext xmesa = XMESA_CONTEXT(ctx);
351 #define RENDER_SPAN( span ) \
354 for (i = 0; i < span.end; i++) { \
355 const DEPTH_TYPE z = FixedToDepth(span.z); \
357 pRow[i] = LOOKUP(FixedToInt(span.red), \
358 FixedToInt(span.green), FixedToInt(span.blue)); \
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_HPCR triangle.
373 #define NAME smooth_HPCR_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 ) \
384 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
385 for (i = 0; i < span.end; i++, x++) { \
386 const DEPTH_TYPE z = FixedToDepth(span.z); \
388 pRow[i] = DITHER_HPCR(x, y, 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, flat, depth-buffered, PF_TRUECOLOR triangle.
404 #define NAME flat_TRUECOLOR_z_triangle
406 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
408 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
409 XMesaImage *img = xmesa->xm_buffer->backimage; \
410 unsigned long pixel; \
411 PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]);
412 #define RENDER_SPAN( span ) \
414 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
415 for (i = 0; i < span.end; i++, x++) { \
416 const DEPTH_TYPE z = FixedToDepth(span.z); \
418 XMesaPutPixel(img, x, y, pixel); \
421 span.z += span.zStep; \
423 #include "swrast/s_tritemp.h"
428 * XImage, flat, depth-buffered, PF_8A8B8G8R triangle.
430 #define NAME flat_8A8B8G8R_z_triangle
432 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
433 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
434 #define PIXEL_TYPE GLuint
435 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
437 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
438 unsigned long p = PACK_8B8G8R( v2->color[0], \
439 v2->color[1], v2->color[2] );
440 #define RENDER_SPAN( span ) \
442 for (i = 0; i < span.end; i++) { \
443 const DEPTH_TYPE z = FixedToDepth(span.z); \
445 pRow[i] = (PIXEL_TYPE) p; \
448 span.z += span.zStep; \
450 #include "swrast/s_tritemp.h"
455 * XImage, flat, depth-buffered, PF_8R8G8B triangle.
457 #define NAME flat_8R8G8B_z_triangle
459 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
460 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
461 #define PIXEL_TYPE GLuint
462 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
464 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
465 unsigned long p = PACK_8R8G8B( v2->color[0], \
466 v2->color[1], v2->color[2] );
467 #define RENDER_SPAN( span ) \
469 for (i = 0; i < span.end; i++) { \
470 DEPTH_TYPE z = FixedToDepth(span.z); \
472 pRow[i] = (PIXEL_TYPE) p; \
475 span.z += span.zStep; \
477 #include "swrast/s_tritemp.h"
482 * XImage, flat, depth-buffered, PF_8R8G8B24 triangle.
484 #define NAME flat_8R8G8B24_z_triangle
486 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
487 #define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
488 #define PIXEL_TYPE bgr_t
489 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
491 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
492 const GLubyte *color = v2->color;
493 #define RENDER_SPAN( span ) \
495 for (i = 0; i < span.end; i++) { \
496 const DEPTH_TYPE z = FixedToDepth(span.z); \
498 PIXEL_TYPE *ptr = pRow + i; \
499 ptr->r = color[RCOMP]; \
500 ptr->g = color[GCOMP]; \
501 ptr->b = color[BCOMP]; \
504 span.z += span.zStep; \
506 #include "swrast/s_tritemp.h"
511 * XImage, flat, depth-buffered, PF_TRUEDITHER triangle.
513 #define NAME flat_TRUEDITHER_z_triangle
515 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
517 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
518 XMesaImage *img = xmesa->xm_buffer->backimage;
519 #define RENDER_SPAN( span ) \
521 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
522 for (i = 0; i < span.end; i++, x++) { \
523 const DEPTH_TYPE z = FixedToDepth(span.z); \
526 PACK_TRUEDITHER(p, x, y, v2->color[0], \
527 v2->color[1], v2->color[2]); \
528 XMesaPutPixel(img, x, y, p); \
531 span.z += span.zStep; \
533 #include "swrast/s_tritemp.h"
538 * XImage, flat, depth-buffered, PF_5R6G5B triangle.
540 #define NAME flat_5R6G5B_z_triangle
542 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
543 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
544 #define PIXEL_TYPE GLushort
545 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
547 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
548 unsigned long p = PACK_5R6G5B( v2->color[0], \
549 v2->color[1], v2->color[2] );
550 #define RENDER_SPAN( span ) \
552 for (i = 0; i < span.end; i++) { \
553 const DEPTH_TYPE z = FixedToDepth(span.z); \
555 pRow[i] = (PIXEL_TYPE) p; \
558 span.z += span.zStep; \
560 #include "swrast/s_tritemp.h"
565 * XImage, flat, depth-buffered, PF_DITHER_5R6G5B triangle.
567 #define NAME flat_DITHER_5R6G5B_z_triangle
569 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
570 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
571 #define PIXEL_TYPE GLushort
572 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
574 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
575 const GLubyte *color = v2->color;
576 #define RENDER_SPAN( span ) \
578 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
579 for (i = 0; i < span.end; i++, x++) { \
580 const DEPTH_TYPE z = FixedToDepth(span.z); \
582 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \
583 color[GCOMP], color[BCOMP]); \
586 span.z += span.zStep; \
588 #include "swrast/s_tritemp.h"
593 * XImage, flat, depth-buffered, 8-bit PF_DITHER triangle.
595 #define NAME flat_DITHER8_z_triangle
597 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
598 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
599 #define PIXEL_TYPE GLubyte
600 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
602 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
603 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
604 #define RENDER_SPAN( span ) \
606 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
607 FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, y)); \
608 for (i = 0; i < span.end; i++, x++) { \
609 const DEPTH_TYPE z = FixedToDepth(span.z); \
611 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x); \
614 span.z += span.zStep; \
616 #include "swrast/s_tritemp.h"
621 * XImage, flat, depth-buffered, PF_DITHER triangle.
623 #define NAME flat_DITHER_z_triangle
625 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
627 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
628 XMesaImage *img = xmesa->xm_buffer->backimage; \
629 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
630 #define RENDER_SPAN( span ) \
632 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
633 FLAT_DITHER_ROW_SETUP(y); \
634 for (i = 0; i < span.end; i++, x++) { \
635 const DEPTH_TYPE z = FixedToDepth(span.z); \
637 unsigned long p = FLAT_DITHER(x); \
638 XMesaPutPixel(img, x, y, p); \
641 span.z += span.zStep; \
643 #include "swrast/s_tritemp.h"
648 * XImage, flat, depth-buffered, 8-bit PF_HPCR triangle.
650 #define NAME flat_HPCR_z_triangle
652 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
653 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
654 #define PIXEL_TYPE GLubyte
655 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
657 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
658 GLubyte r = v2->color[0]; \
659 GLubyte g = v2->color[1]; \
660 GLubyte b = v2->color[2];
661 #define RENDER_SPAN( span ) \
663 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
664 for (i = 0; i < span.end; i++, x++) { \
665 const DEPTH_TYPE z = FixedToDepth(span.z); \
667 pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b); \
670 span.z += span.zStep; \
672 #include "swrast/s_tritemp.h"
677 * XImage, flat, depth-buffered, 8-bit PF_LOOKUP triangle.
679 #define NAME flat_LOOKUP8_z_triangle
681 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
682 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
683 #define PIXEL_TYPE GLubyte
684 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
686 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
688 GLubyte r = v2->color[0]; \
689 GLubyte g = v2->color[1]; \
690 GLubyte b = v2->color[2]; \
691 GLubyte p = LOOKUP(r,g,b);
692 #define RENDER_SPAN( span ) \
694 for (i = 0; i < span.end; i++) { \
695 const DEPTH_TYPE z = FixedToDepth(span.z); \
700 span.z += span.zStep; \
702 #include "swrast/s_tritemp.h"
707 * XImage, smooth, NON-depth-buffered, PF_TRUECOLOR triangle.
709 #define NAME smooth_TRUECOLOR_triangle
712 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
713 XMesaImage *img = xmesa->xm_buffer->backimage;
714 #define RENDER_SPAN( span ) \
716 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
717 for (i = 0; i < span.end; i++, x++) { \
719 PACK_TRUECOLOR(p, FixedToInt(span.red), \
720 FixedToInt(span.green), FixedToInt(span.blue)); \
721 XMesaPutPixel(img, x, y, p); \
722 span.red += span.redStep; \
723 span.green += span.greenStep; \
724 span.blue += span.blueStep; \
726 #include "swrast/s_tritemp.h"
731 * XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle.
733 #define NAME smooth_8A8B8G8R_triangle
735 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
736 #define PIXEL_TYPE GLuint
737 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
739 XMesaContext xmesa = XMESA_CONTEXT(ctx);
740 #define RENDER_SPAN( span ) \
742 for (i = 0; i < span.end; i++) { \
743 pRow[i] = PACK_8B8G8R(FixedToInt(span.red), \
744 FixedToInt(span.green), FixedToInt(span.blue) ); \
745 span.red += span.redStep; \
746 span.green += span.greenStep; \
747 span.blue += span.blueStep; \
749 #include "swrast/s_tritemp.h"
754 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
756 #define NAME smooth_8R8G8B_triangle
758 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
759 #define PIXEL_TYPE GLuint
760 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
762 XMesaContext xmesa = XMESA_CONTEXT(ctx);
763 #define RENDER_SPAN( span ) \
765 for (i = 0; i < span.end; i++) { \
766 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
767 FixedToInt(span.green), FixedToInt(span.blue) ); \
768 span.red += span.redStep; \
769 span.green += span.greenStep; \
770 span.blue += span.blueStep; \
772 #include "swrast/s_tritemp.h"
777 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
779 #define NAME smooth_8R8G8B24_triangle
781 #define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
782 #define PIXEL_TYPE bgr_t
783 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
785 XMesaContext xmesa = XMESA_CONTEXT(ctx);
786 #define RENDER_SPAN( span ) \
788 PIXEL_TYPE *pixel = pRow; \
789 for (i = 0; i < span.end; i++, pixel++) { \
790 pixel->r = FixedToInt(span.red); \
791 pixel->g = FixedToInt(span.green); \
792 pixel->b = FixedToInt(span.blue); \
793 span.red += span.redStep; \
794 span.green += span.greenStep; \
795 span.blue += span.blueStep; \
797 #include "swrast/s_tritemp.h"
802 * XImage, smooth, NON-depth-buffered, PF_TRUEDITHER triangle.
804 #define NAME smooth_TRUEDITHER_triangle
807 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
808 XMesaImage *img = xmesa->xm_buffer->backimage;
809 #define RENDER_SPAN( span ) \
811 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
812 for (i = 0; i < span.end; i++, x++) { \
814 PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \
815 FixedToInt(span.green), FixedToInt(span.blue)); \
816 XMesaPutPixel(img, x, y, p ); \
817 span.red += span.redStep; \
818 span.green += span.greenStep; \
819 span.blue += span.blueStep; \
821 #include "swrast/s_tritemp.h"
826 * XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle.
828 #define NAME smooth_5R6G5B_triangle
830 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
831 #define PIXEL_TYPE GLushort
832 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
834 XMesaContext xmesa = XMESA_CONTEXT(ctx);
835 #define RENDER_SPAN( span ) \
837 for (i = 0; i < span.end; i++) { \
838 pRow[i] = (PIXEL_TYPE) PACK_5R6G5B(FixedToInt(span.red), \
839 FixedToInt(span.green), FixedToInt(span.blue)); \
840 span.red += span.redStep; \
841 span.green += span.greenStep; \
842 span.blue += span.blueStep; \
844 #include "swrast/s_tritemp.h"
849 * XImage, smooth, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
851 #define NAME smooth_DITHER_5R6G5B_triangle
853 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
854 #define PIXEL_TYPE GLushort
855 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
857 XMesaContext xmesa = XMESA_CONTEXT(ctx);
858 #define RENDER_SPAN( span ) \
860 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
861 for (i = 0; i < span.end; i++, x++) { \
862 PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \
863 FixedToInt(span.green), FixedToInt(span.blue)); \
864 span.red += span.redStep; \
865 span.green += span.greenStep; \
866 span.blue += span.blueStep; \
868 #include "swrast/s_tritemp.h"
873 * XImage, smooth, NON-depth-buffered, 8-bit PF_DITHER triangle.
875 #define NAME smooth_DITHER8_triangle
877 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
878 #define PIXEL_TYPE GLubyte
879 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
881 XMesaContext xmesa = XMESA_CONTEXT(ctx);
882 #define RENDER_SPAN( span ) \
884 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
886 for (i = 0; i < span.end; i++, x++) { \
887 pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red), \
888 FixedToInt(span.green), FixedToInt(span.blue) ); \
889 span.red += span.redStep; \
890 span.green += span.greenStep; \
891 span.blue += span.blueStep; \
893 #include "swrast/s_tritemp.h"
898 * XImage, smooth, NON-depth-buffered, PF_DITHER triangle.
900 #define NAME smooth_DITHER_triangle
903 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
904 XMesaImage *img = xmesa->xm_buffer->backimage;
905 #define RENDER_SPAN( span ) \
907 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
909 for (i = 0; i < span.end; i++, x++) { \
910 unsigned long p = XDITHER(x, FixedToInt(span.red), \
911 FixedToInt(span.green), FixedToInt(span.blue) ); \
912 XMesaPutPixel(img, x, y, p); \
913 span.red += span.redStep; \
914 span.green += span.greenStep; \
915 span.blue += span.blueStep; \
917 #include "swrast/s_tritemp.h"
922 * XImage, smooth, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
924 #define NAME smooth_LOOKUP8_triangle
926 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
927 #define PIXEL_TYPE GLubyte
928 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
930 XMesaContext xmesa = XMESA_CONTEXT(ctx);
931 #define RENDER_SPAN( span ) \
934 for (i = 0; i < span.end; i++) { \
935 pRow[i] = LOOKUP(FixedToInt(span.red), \
936 FixedToInt(span.green), FixedToInt(span.blue)); \
937 span.red += span.redStep; \
938 span.green += span.greenStep; \
939 span.blue += span.blueStep; \
941 #include "swrast/s_tritemp.h"
946 * XImage, smooth, NON-depth-buffered, 8-bit PF_HPCR triangle.
948 #define NAME smooth_HPCR_triangle
950 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
951 #define PIXEL_TYPE GLubyte
952 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
954 XMesaContext xmesa = XMESA_CONTEXT(ctx);
955 #define RENDER_SPAN( span ) \
957 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
958 for (i = 0; i < span.end; i++, x++) { \
959 pRow[i] = DITHER_HPCR(x, y, FixedToInt(span.red), \
960 FixedToInt(span.green), FixedToInt(span.blue)); \
961 span.red += span.redStep; \
962 span.green += span.greenStep; \
963 span.blue += span.blueStep; \
965 #include "swrast/s_tritemp.h"
970 * XImage, flat, NON-depth-buffered, PF_TRUECOLOR triangle.
972 #define NAME flat_TRUECOLOR_triangle
974 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
975 XMesaImage *img = xmesa->xm_buffer->backimage; \
976 unsigned long pixel; \
977 PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]);
978 #define RENDER_SPAN( span ) \
980 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
981 for (i = 0; i < span.end; i++, x++) { \
982 XMesaPutPixel(img, x, y, pixel); \
984 #include "swrast/s_tritemp.h"
989 * XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle.
991 #define NAME flat_8A8B8G8R_triangle
992 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
993 #define PIXEL_TYPE GLuint
994 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
996 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
997 unsigned long p = PACK_8B8G8R( v2->color[0], \
998 v2->color[1], v2->color[2] );
999 #define RENDER_SPAN( span ) \
1001 for (i = 0; i < span.end; i++) { \
1002 pRow[i] = (PIXEL_TYPE) p; \
1004 #include "swrast/s_tritemp.h"
1009 * XImage, flat, NON-depth-buffered, PF_8R8G8B triangle.
1011 #define NAME flat_8R8G8B_triangle
1012 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
1013 #define PIXEL_TYPE GLuint
1014 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1015 #define SETUP_CODE \
1016 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1017 unsigned long p = PACK_8R8G8B( v2->color[0], \
1018 v2->color[1], v2->color[2] );
1019 #define RENDER_SPAN( span ) \
1021 for (i = 0; i < span.end; i++) { \
1022 pRow[i] = (PIXEL_TYPE) p; \
1024 #include "swrast/s_tritemp.h"
1029 * XImage, flat, NON-depth-buffered, PF_8R8G8B24 triangle.
1031 #define NAME flat_8R8G8B24_triangle
1032 #define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
1033 #define PIXEL_TYPE bgr_t
1034 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1035 #define SETUP_CODE \
1036 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1037 const GLubyte *color = v2->color;
1038 #define RENDER_SPAN( span ) \
1040 PIXEL_TYPE *pixel = pRow; \
1041 for (i = 0; i < span.end; i++, pixel++) { \
1042 pixel->r = color[RCOMP]; \
1043 pixel->g = color[GCOMP]; \
1044 pixel->b = color[BCOMP]; \
1046 #include "swrast/s_tritemp.h"
1051 * XImage, flat, NON-depth-buffered, PF_TRUEDITHER triangle.
1053 #define NAME flat_TRUEDITHER_triangle
1054 #define SETUP_CODE \
1055 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1056 XMesaImage *img = xmesa->xm_buffer->backimage;
1057 #define RENDER_SPAN( span ) \
1059 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
1060 for (i = 0; i < span.end; i++, x++) { \
1062 PACK_TRUEDITHER(p, x, y, v2->color[0], \
1063 v2->color[1], v2->color[2] ); \
1064 XMesaPutPixel(img, x, y, p); \
1066 #include "swrast/s_tritemp.h"
1071 * XImage, flat, NON-depth-buffered, PF_5R6G5B triangle.
1073 #define NAME flat_5R6G5B_triangle
1074 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
1075 #define PIXEL_TYPE GLushort
1076 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1077 #define SETUP_CODE \
1078 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1079 unsigned long p = PACK_5R6G5B( v2->color[0], \
1080 v2->color[1], v2->color[2] );
1081 #define RENDER_SPAN( span ) \
1083 for (i = 0; i < span.end; i++) { \
1084 pRow[i] = (PIXEL_TYPE) p; \
1086 #include "swrast/s_tritemp.h"
1091 * XImage, flat, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
1093 #define NAME flat_DITHER_5R6G5B_triangle
1094 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
1095 #define PIXEL_TYPE GLushort
1096 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1097 #define SETUP_CODE \
1098 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1099 const GLubyte *color = v2->color;
1100 #define RENDER_SPAN( span ) \
1102 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
1103 for (i = 0; i < span.end; i++, x++) { \
1104 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \
1105 color[GCOMP], color[BCOMP]); \
1107 #include "swrast/s_tritemp.h"
1112 * XImage, flat, NON-depth-buffered, 8-bit PF_DITHER triangle.
1114 #define NAME flat_DITHER8_triangle
1115 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
1116 #define PIXEL_TYPE GLubyte
1117 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1118 #define SETUP_CODE \
1119 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1120 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
1121 #define RENDER_SPAN( span ) \
1123 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
1124 FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, y)); \
1125 for (i = 0; i < span.end; i++, x++) { \
1126 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x); \
1128 #include "swrast/s_tritemp.h"
1133 * XImage, flat, NON-depth-buffered, PF_DITHER triangle.
1135 #define NAME flat_DITHER_triangle
1136 #define SETUP_CODE \
1137 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1138 XMesaImage *img = xmesa->xm_buffer->backimage; \
1139 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
1140 #define RENDER_SPAN( span ) \
1142 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
1143 FLAT_DITHER_ROW_SETUP(y); \
1144 for (i = 0; i < span.end; i++, x++) { \
1145 unsigned long p = FLAT_DITHER(x); \
1146 XMesaPutPixel(img, x, y, p ); \
1148 #include "swrast/s_tritemp.h"
1153 * XImage, flat, NON-depth-buffered, 8-bit PF_HPCR triangle.
1155 #define NAME flat_HPCR_triangle
1156 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
1157 #define PIXEL_TYPE GLubyte
1158 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1159 #define SETUP_CODE \
1160 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1161 GLubyte r = v2->color[0]; \
1162 GLubyte g = v2->color[1]; \
1163 GLubyte b = v2->color[2];
1164 #define RENDER_SPAN( span ) \
1166 GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
1167 for (i = 0; i < span.end; i++, x++) { \
1168 pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b); \
1170 #include "swrast/s_tritemp.h"
1175 * XImage, flat, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
1177 #define NAME flat_LOOKUP8_triangle
1178 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
1179 #define PIXEL_TYPE GLubyte
1180 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1181 #define SETUP_CODE \
1182 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1184 GLubyte r = v2->color[0]; \
1185 GLubyte g = v2->color[1]; \
1186 GLubyte b = v2->color[2]; \
1187 GLubyte p = LOOKUP(r,g,b);
1188 #define RENDER_SPAN( span ) \
1190 for (i = 0; i < span.end; i++) { \
1191 pRow[i] = (PIXEL_TYPE) p; \
1193 #include "swrast/s_tritemp.h"
1198 extern void _xmesa_print_triangle_func( swrast_tri_func triFunc
);
1199 void _xmesa_print_triangle_func( swrast_tri_func triFunc
)
1201 _mesa_printf("XMesa tri func = ");
1202 if (triFunc
==smooth_TRUECOLOR_z_triangle
)
1203 _mesa_printf("smooth_TRUECOLOR_z_triangle\n");
1204 else if (triFunc
==smooth_8A8B8G8R_z_triangle
)
1205 _mesa_printf("smooth_8A8B8G8R_z_triangle\n");
1206 else if (triFunc
==smooth_8R8G8B_z_triangle
)
1207 _mesa_printf("smooth_8R8G8B_z_triangle\n");
1208 else if (triFunc
==smooth_8R8G8B24_z_triangle
)
1209 _mesa_printf("smooth_8R8G8B24_z_triangle\n");
1210 else if (triFunc
==smooth_TRUEDITHER_z_triangle
)
1211 _mesa_printf("smooth_TRUEDITHER_z_triangle\n");
1212 else if (triFunc
==smooth_5R6G5B_z_triangle
)
1213 _mesa_printf("smooth_5R6G5B_z_triangle\n");
1214 else if (triFunc
==smooth_DITHER_5R6G5B_z_triangle
)
1215 _mesa_printf("smooth_DITHER_5R6G5B_z_triangle\n");
1216 else if (triFunc
==smooth_HPCR_z_triangle
)
1217 _mesa_printf("smooth_HPCR_z_triangle\n");
1218 else if (triFunc
==smooth_DITHER8_z_triangle
)
1219 _mesa_printf("smooth_DITHER8_z_triangle\n");
1220 else if (triFunc
==smooth_LOOKUP8_z_triangle
)
1221 _mesa_printf("smooth_LOOKUP8_z_triangle\n");
1222 else if (triFunc
==flat_TRUECOLOR_z_triangle
)
1223 _mesa_printf("flat_TRUECOLOR_z_triangle\n");
1224 else if (triFunc
==flat_8A8B8G8R_z_triangle
)
1225 _mesa_printf("flat_8A8B8G8R_z_triangle\n");
1226 else if (triFunc
==flat_8R8G8B_z_triangle
)
1227 _mesa_printf("flat_8R8G8B_z_triangle\n");
1228 else if (triFunc
==flat_8R8G8B24_z_triangle
)
1229 _mesa_printf("flat_8R8G8B24_z_triangle\n");
1230 else if (triFunc
==flat_TRUEDITHER_z_triangle
)
1231 _mesa_printf("flat_TRUEDITHER_z_triangle\n");
1232 else if (triFunc
==flat_5R6G5B_z_triangle
)
1233 _mesa_printf("flat_5R6G5B_z_triangle\n");
1234 else if (triFunc
==flat_DITHER_5R6G5B_z_triangle
)
1235 _mesa_printf("flat_DITHER_5R6G5B_z_triangle\n");
1236 else if (triFunc
==flat_HPCR_z_triangle
)
1237 _mesa_printf("flat_HPCR_z_triangle\n");
1238 else if (triFunc
==flat_DITHER8_z_triangle
)
1239 _mesa_printf("flat_DITHER8_z_triangle\n");
1240 else if (triFunc
==flat_LOOKUP8_z_triangle
)
1241 _mesa_printf("flat_LOOKUP8_z_triangle\n");
1242 else if (triFunc
==smooth_TRUECOLOR_triangle
)
1243 _mesa_printf("smooth_TRUECOLOR_triangle\n");
1244 else if (triFunc
==smooth_8A8B8G8R_triangle
)
1245 _mesa_printf("smooth_8A8B8G8R_triangle\n");
1246 else if (triFunc
==smooth_8R8G8B_triangle
)
1247 _mesa_printf("smooth_8R8G8B_triangle\n");
1248 else if (triFunc
==smooth_8R8G8B24_triangle
)
1249 _mesa_printf("smooth_8R8G8B24_triangle\n");
1250 else if (triFunc
==smooth_TRUEDITHER_triangle
)
1251 _mesa_printf("smooth_TRUEDITHER_triangle\n");
1252 else if (triFunc
==smooth_5R6G5B_triangle
)
1253 _mesa_printf("smooth_5R6G5B_triangle\n");
1254 else if (triFunc
==smooth_DITHER_5R6G5B_triangle
)
1255 _mesa_printf("smooth_DITHER_5R6G5B_triangle\n");
1256 else if (triFunc
==smooth_HPCR_triangle
)
1257 _mesa_printf("smooth_HPCR_triangle\n");
1258 else if (triFunc
==smooth_DITHER8_triangle
)
1259 _mesa_printf("smooth_DITHER8_triangle\n");
1260 else if (triFunc
==smooth_LOOKUP8_triangle
)
1261 _mesa_printf("smooth_LOOKUP8_triangle\n");
1262 else if (triFunc
==flat_TRUECOLOR_triangle
)
1263 _mesa_printf("flat_TRUECOLOR_triangle\n");
1264 else if (triFunc
==flat_TRUEDITHER_triangle
)
1265 _mesa_printf("flat_TRUEDITHER_triangle\n");
1266 else if (triFunc
==flat_8A8B8G8R_triangle
)
1267 _mesa_printf("flat_8A8B8G8R_triangle\n");
1268 else if (triFunc
==flat_8R8G8B_triangle
)
1269 _mesa_printf("flat_8R8G8B_triangle\n");
1270 else if (triFunc
==flat_8R8G8B24_triangle
)
1271 _mesa_printf("flat_8R8G8B24_triangle\n");
1272 else if (triFunc
==flat_5R6G5B_triangle
)
1273 _mesa_printf("flat_5R6G5B_triangle\n");
1274 else if (triFunc
==flat_DITHER_5R6G5B_triangle
)
1275 _mesa_printf("flat_DITHER_5R6G5B_triangle\n");
1276 else if (triFunc
==flat_HPCR_triangle
)
1277 _mesa_printf("flat_HPCR_triangle\n");
1278 else if (triFunc
==flat_DITHER8_triangle
)
1279 _mesa_printf("flat_DITHER8_triangle\n");
1280 else if (triFunc
==flat_LOOKUP8_triangle
)
1281 _mesa_printf("flat_LOOKUP8_triangle\n");
1283 _mesa_printf("???\n");
1290 /* record the current triangle function name */
1291 static const char *triFuncName
= NULL
;
1293 #define USE(triFunc) \
1295 triFuncName = #triFunc; \
1301 #define USE(triFunc) return triFunc
1306 static swrast_tri_func
get_triangle_func( GLcontext
*ctx
)
1308 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
1309 XMesaContext xmesa
= XMESA_CONTEXT(ctx
);
1310 int depth
= GET_VISUAL_DEPTH(xmesa
->xm_visual
);
1316 if ((ctx
->Color
._DrawDestMask
& (DD_FRONT_LEFT_BIT
| DD_BACK_LEFT_BIT
)) ==0)
1317 return (swrast_tri_func
) NULL
;
1318 if (ctx
->RenderMode
!= GL_RENDER
) return (swrast_tri_func
) NULL
;
1319 if (ctx
->Polygon
.SmoothFlag
) return (swrast_tri_func
) NULL
;
1320 if (ctx
->Texture
._EnabledUnits
) return (swrast_tri_func
) NULL
;
1321 if (swrast
->_RasterMask
& MULTI_DRAW_BIT
) return (swrast_tri_func
) NULL
;
1322 if (ctx
->Polygon
.CullFlag
&&
1323 ctx
->Polygon
.CullFaceMode
== GL_FRONT_AND_BACK
)
1324 return (swrast_tri_func
) NULL
;
1326 if (xmesa
->xm_buffer
->buffer
==XIMAGE
) {
1327 if ( ctx
->Light
.ShadeModel
==GL_SMOOTH
1328 && swrast
->_RasterMask
==DEPTH_BIT
1329 && ctx
->Depth
.Func
==GL_LESS
1330 && ctx
->Depth
.Mask
==GL_TRUE
1331 && ctx
->Visual
.depthBits
== DEFAULT_SOFTWARE_DEPTH_BITS
1332 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1333 switch (xmesa
->pixelformat
) {
1335 USE(smooth_TRUECOLOR_z_triangle
);
1337 USE(smooth_8A8B8G8R_z_triangle
);
1339 USE(smooth_8R8G8B_z_triangle
);
1341 USE(smooth_8R8G8B24_z_triangle
);
1342 case PF_Dither_True
:
1343 USE(smooth_TRUEDITHER_z_triangle
);
1345 USE(smooth_5R6G5B_z_triangle
);
1346 case PF_Dither_5R6G5B
:
1347 USE(smooth_DITHER_5R6G5B_z_triangle
);
1349 USE(smooth_HPCR_z_triangle
);
1352 USE(smooth_DITHER8_z_triangle
);
1354 USE(smooth_DITHER_z_triangle
);
1358 USE(smooth_LOOKUP8_z_triangle
);
1360 return (swrast_tri_func
) NULL
;
1362 return (swrast_tri_func
) NULL
;
1365 if ( ctx
->Light
.ShadeModel
==GL_FLAT
1366 && swrast
->_RasterMask
==DEPTH_BIT
1367 && ctx
->Depth
.Func
==GL_LESS
1368 && ctx
->Depth
.Mask
==GL_TRUE
1369 && ctx
->Visual
.depthBits
== DEFAULT_SOFTWARE_DEPTH_BITS
1370 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1371 switch (xmesa
->pixelformat
) {
1373 USE(flat_TRUECOLOR_z_triangle
);
1375 USE(flat_8A8B8G8R_z_triangle
);
1377 USE(flat_8R8G8B_z_triangle
);
1379 USE(flat_8R8G8B24_z_triangle
);
1380 case PF_Dither_True
:
1381 USE(flat_TRUEDITHER_z_triangle
);
1383 USE(flat_5R6G5B_z_triangle
);
1384 case PF_Dither_5R6G5B
:
1385 USE(flat_DITHER_5R6G5B_z_triangle
);
1387 USE(flat_HPCR_z_triangle
);
1390 USE(flat_DITHER8_z_triangle
);
1392 USE(flat_DITHER_z_triangle
);
1396 USE(flat_LOOKUP8_z_triangle
);
1398 return (swrast_tri_func
) NULL
;
1400 return (swrast_tri_func
) NULL
;
1403 if ( swrast
->_RasterMask
==0 /* no depth test */
1404 && ctx
->Light
.ShadeModel
==GL_SMOOTH
1405 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1406 switch (xmesa
->pixelformat
) {
1408 USE(smooth_TRUECOLOR_triangle
);
1410 USE(smooth_8A8B8G8R_triangle
);
1412 USE(smooth_8R8G8B_triangle
);
1414 USE(smooth_8R8G8B24_triangle
);
1415 case PF_Dither_True
:
1416 USE(smooth_TRUEDITHER_triangle
);
1418 USE(smooth_5R6G5B_triangle
);
1419 case PF_Dither_5R6G5B
:
1420 USE(smooth_DITHER_5R6G5B_triangle
);
1422 USE(smooth_HPCR_triangle
);
1425 USE(smooth_DITHER8_triangle
);
1427 USE(smooth_DITHER_triangle
);
1431 USE(smooth_LOOKUP8_triangle
);
1433 return (swrast_tri_func
) NULL
;
1435 return (swrast_tri_func
) NULL
;
1439 if ( swrast
->_RasterMask
==0 /* no depth test */
1440 && ctx
->Light
.ShadeModel
==GL_FLAT
1441 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1442 switch (xmesa
->pixelformat
) {
1444 USE(flat_TRUECOLOR_triangle
);
1445 case PF_Dither_True
:
1446 USE(flat_TRUEDITHER_triangle
);
1448 USE(flat_8A8B8G8R_triangle
);
1450 USE(flat_8R8G8B_triangle
);
1452 USE(flat_8R8G8B24_triangle
);
1454 USE(flat_5R6G5B_triangle
);
1455 case PF_Dither_5R6G5B
:
1456 USE(flat_DITHER_5R6G5B_triangle
);
1458 USE(flat_HPCR_triangle
);
1461 USE(flat_DITHER8_triangle
);
1463 USE(flat_DITHER_triangle
);
1467 USE(flat_LOOKUP8_triangle
);
1469 return (swrast_tri_func
) NULL
;
1471 return (swrast_tri_func
) NULL
;
1475 return (swrast_tri_func
) NULL
;
1478 /* draw to pixmap */
1479 return (swrast_tri_func
) NULL
;
1484 /* Override for the swrast tri-selection function. Try to use one
1485 * of our internal tri functions, otherwise fall back to the
1486 * standard swrast functions.
1488 void xmesa_choose_triangle( GLcontext
*ctx
)
1490 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
1492 if (!(swrast
->Triangle
= get_triangle_func( ctx
)))
1493 _swrast_choose_triangle( ctx
);