2 * Mesa 3-D graphics library
4 * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * 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.
35 #include "main/imports.h"
36 #include "main/mtypes.h"
37 #include "glxheader.h"
40 /* Internal swrast includes:
42 #include "swrast/s_context.h"
43 #include "swrast/s_depth.h"
44 #include "swrast/s_triangle.h"
47 #define GET_XRB(XRB) struct xmesa_renderbuffer *XRB = \
48 xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0])
51 /**********************************************************************/
52 /*** Triangle rendering ***/
53 /**********************************************************************/
59 * XImage, smooth, depth-buffered, PF_TRUECOLOR triangle.
61 #define NAME smooth_TRUECOLOR_z_triangle
63 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
66 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
69 #define RENDER_SPAN( span ) { \
70 GLint x = span.x, y = YFLIP(xrb, span.y); \
72 for (i = 0; i < span.end; i++, x++) { \
73 const DEPTH_TYPE z = FixedToDepth(span.z); \
76 PACK_TRUECOLOR(p, FixedToInt(span.red), \
77 FixedToInt(span.green), FixedToInt(span.blue)); \
78 XMesaPutPixel(xrb->ximage, x, y, p); \
81 span.red += span.redStep; \
82 span.green += span.greenStep; \
83 span.blue += span.blueStep; \
84 span.z += span.zStep; \
87 #include "swrast/s_tritemp.h"
93 * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle.
95 #define NAME smooth_8A8B8G8R_z_triangle
97 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
99 #define INTERP_ALPHA 1
100 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
101 #define PIXEL_TYPE GLuint
102 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
105 #define RENDER_SPAN( span ) { \
107 for (i = 0; i < span.end; i++) { \
108 const DEPTH_TYPE z = FixedToDepth(span.z); \
110 pRow[i] = PACK_8A8B8G8R(FixedToInt(span.red), \
111 FixedToInt(span.green), FixedToInt(span.blue), \
112 FixedToInt(span.alpha)); \
115 span.red += span.redStep; \
116 span.green += span.greenStep; \
117 span.blue += span.blueStep; \
118 span.alpha += span.alphaStep; \
119 span.z += span.zStep; \
122 #include "swrast/s_tritemp.h"
127 * XImage, smooth, depth-buffered, PF_8A8R8G8B triangle.
129 #define NAME smooth_8A8R8G8B_z_triangle
131 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
133 #define INTERP_ALPHA 1
134 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
135 #define PIXEL_TYPE GLuint
136 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
140 #define RENDER_SPAN( span ) { \
142 for (i = 0; i < span.end; i++) { \
143 const DEPTH_TYPE z = FixedToDepth(span.z); \
145 pRow[i] = PACK_8A8R8G8B(FixedToInt(span.red), \
146 FixedToInt(span.green), FixedToInt(span.blue), \
147 FixedToInt(span.alpha)); \
150 span.red += span.redStep; \
151 span.green += span.greenStep; \
152 span.blue += span.blueStep; \
153 span.alpha += span.alphaStep; \
154 span.z += span.zStep; \
157 #include "swrast/s_tritemp.h"
162 * XImage, smooth, depth-buffered, PF_8R8G8B triangle.
164 #define NAME smooth_8R8G8B_z_triangle
166 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
168 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
169 #define PIXEL_TYPE GLuint
170 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
174 #define RENDER_SPAN( span ) { \
176 for (i = 0; i < span.end; i++) { \
177 const DEPTH_TYPE z = FixedToDepth(span.z); \
179 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
180 FixedToInt(span.green), FixedToInt(span.blue)); \
183 span.red += span.redStep; \
184 span.green += span.greenStep; \
185 span.blue += span.blueStep; \
186 span.z += span.zStep; \
189 #include "swrast/s_tritemp.h"
194 * XImage, smooth, depth-buffered, PF_8R8G8B24 triangle.
196 #define NAME smooth_8R8G8B24_z_triangle
198 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
200 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
201 #define PIXEL_TYPE bgr_t
202 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
205 #define RENDER_SPAN( span ) { \
207 for (i = 0; i < span.end; i++) { \
208 const DEPTH_TYPE z = FixedToDepth(span.z); \
210 PIXEL_TYPE *ptr = pRow + i; \
211 ptr->r = FixedToInt(span.red); \
212 ptr->g = FixedToInt(span.green); \
213 ptr->b = FixedToInt(span.blue); \
216 span.red += span.redStep; \
217 span.green += span.greenStep; \
218 span.blue += span.blueStep; \
219 span.z += span.zStep; \
221 #include "swrast/s_tritemp.h"
226 * XImage, smooth, depth-buffered, PF_TRUEDITHER triangle.
228 #define NAME smooth_TRUEDITHER_z_triangle
230 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
233 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
235 #define RENDER_SPAN( span ) { \
237 GLint x = span.x, y = YFLIP(xrb, span.y); \
238 for (i = 0; i < span.end; i++, x++) { \
239 const DEPTH_TYPE z = FixedToDepth(span.z); \
242 PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \
243 FixedToInt(span.green), FixedToInt(span.blue)); \
244 XMesaPutPixel(xrb->ximage, x, y, p); \
247 span.red += span.redStep; \
248 span.green += span.greenStep; \
249 span.blue += span.blueStep; \
250 span.z += span.zStep; \
252 #include "swrast/s_tritemp.h"
257 * XImage, smooth, depth-buffered, PF_5R6G5B triangle.
259 #define NAME smooth_5R6G5B_z_triangle
261 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
263 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
264 #define PIXEL_TYPE GLushort
265 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
268 #define RENDER_SPAN( span ) { \
270 for (i = 0; i < span.end; i++) { \
271 const DEPTH_TYPE z = FixedToDepth(span.z); \
273 pRow[i] = PACK_5R6G5B(FixedToInt(span.red), \
274 FixedToInt(span.green), FixedToInt(span.blue)); \
277 span.red += span.redStep; \
278 span.green += span.greenStep; \
279 span.blue += span.blueStep; \
280 span.z += span.zStep; \
282 #include "swrast/s_tritemp.h"
287 * XImage, smooth, depth-buffered, PF_DITHER_5R6G5B triangle.
289 #define NAME smooth_DITHER_5R6G5B_z_triangle
291 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
293 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
294 #define PIXEL_TYPE GLushort
295 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
297 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
299 #define RENDER_SPAN( span ) { \
301 GLint x = span.x, y = YFLIP(xrb, span.y); \
302 for (i = 0; i < span.end; i++, x++) { \
303 const DEPTH_TYPE z = FixedToDepth(span.z); \
305 PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \
306 FixedToInt(span.green), FixedToInt(span.blue)); \
309 span.red += span.redStep; \
310 span.green += span.greenStep; \
311 span.blue += span.blueStep; \
312 span.z += span.zStep; \
314 #include "swrast/s_tritemp.h"
319 * XImage, flat, depth-buffered, PF_TRUECOLOR triangle.
321 #define NAME flat_TRUECOLOR_z_triangle
323 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
325 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
327 XMesaImage *img = xrb->ximage; \
328 unsigned long pixel; \
329 PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]);
330 #define RENDER_SPAN( span ) { \
332 GLint x = span.x, y = YFLIP(xrb, span.y); \
333 for (i = 0; i < span.end; i++, x++) { \
334 const DEPTH_TYPE z = FixedToDepth(span.z); \
336 XMesaPutPixel(img, x, y, pixel); \
339 span.z += span.zStep; \
341 #include "swrast/s_tritemp.h"
346 * XImage, flat, depth-buffered, PF_8A8B8G8R triangle.
348 #define NAME flat_8A8B8G8R_z_triangle
350 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
351 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
352 #define PIXEL_TYPE GLuint
353 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
356 GLuint p = PACK_8A8B8G8R( v2->color[0], v2->color[1],\
357 v2->color[2], v2->color[3]);
358 #define RENDER_SPAN( span ) { \
360 for (i = 0; i < span.end; i++) { \
361 const DEPTH_TYPE z = FixedToDepth(span.z); \
363 pRow[i] = (PIXEL_TYPE) p; \
366 span.z += span.zStep; \
368 #include "swrast/s_tritemp.h"
373 * XImage, flat, depth-buffered, PF_8A8R8G8B triangle.
375 #define NAME flat_8A8R8G8B_z_triangle
377 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
378 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
379 #define PIXEL_TYPE GLuint
380 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
383 GLuint p = PACK_8A8R8G8B(v2->color[0], v2->color[1], \
384 v2->color[2], v2->color[3]);
385 #define RENDER_SPAN( span ) { \
387 for (i = 0; i < span.end; i++) { \
388 const DEPTH_TYPE z = FixedToDepth(span.z); \
390 pRow[i] = (PIXEL_TYPE) p; \
393 span.z += span.zStep; \
395 #include "swrast/s_tritemp.h"
400 * XImage, flat, depth-buffered, PF_8R8G8B triangle.
402 #define NAME flat_8R8G8B_z_triangle
404 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
405 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
406 #define PIXEL_TYPE GLuint
407 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
410 GLuint p = PACK_8R8G8B( v2->color[0], v2->color[1], v2->color[2] );
411 #define RENDER_SPAN( span ) { \
413 for (i = 0; i < span.end; i++) { \
414 DEPTH_TYPE z = FixedToDepth(span.z); \
416 pRow[i] = (PIXEL_TYPE) p; \
419 span.z += span.zStep; \
422 #include "swrast/s_tritemp.h"
427 * XImage, flat, depth-buffered, PF_8R8G8B24 triangle.
429 #define NAME flat_8R8G8B24_z_triangle
431 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
432 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
433 #define PIXEL_TYPE bgr_t
434 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
437 const GLubyte *color = v2->color;
438 #define RENDER_SPAN( span ) { \
440 for (i = 0; i < span.end; i++) { \
441 const DEPTH_TYPE z = FixedToDepth(span.z); \
443 PIXEL_TYPE *ptr = pRow + i; \
444 ptr->r = color[RCOMP]; \
445 ptr->g = color[GCOMP]; \
446 ptr->b = color[BCOMP]; \
449 span.z += span.zStep; \
451 #include "swrast/s_tritemp.h"
456 * XImage, flat, depth-buffered, PF_TRUEDITHER triangle.
458 #define NAME flat_TRUEDITHER_z_triangle
460 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
462 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
464 XMesaImage *img = xrb->ximage;
465 #define RENDER_SPAN( span ) { \
467 GLint x = span.x, y = YFLIP(xrb, span.y); \
468 for (i = 0; i < span.end; i++, x++) { \
469 const DEPTH_TYPE z = FixedToDepth(span.z); \
472 PACK_TRUEDITHER(p, x, y, v2->color[0], \
473 v2->color[1], v2->color[2]); \
474 XMesaPutPixel(img, x, y, p); \
477 span.z += span.zStep; \
479 #include "swrast/s_tritemp.h"
484 * XImage, flat, depth-buffered, PF_5R6G5B triangle.
486 #define NAME flat_5R6G5B_z_triangle
488 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
489 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
490 #define PIXEL_TYPE GLushort
491 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
494 GLushort p = PACK_5R6G5B( v2->color[0], v2->color[1], v2->color[2] );
495 #define RENDER_SPAN( span ) { \
497 for (i = 0; i < span.end; i++) { \
498 const DEPTH_TYPE z = FixedToDepth(span.z); \
500 pRow[i] = (PIXEL_TYPE) p; \
503 span.z += span.zStep; \
505 #include "swrast/s_tritemp.h"
510 * XImage, flat, depth-buffered, PF_DITHER_5R6G5B triangle.
512 #define NAME flat_DITHER_5R6G5B_z_triangle
514 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
515 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
516 #define PIXEL_TYPE GLushort
517 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
519 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
521 const GLubyte *color = v2->color;
522 #define RENDER_SPAN( span ) { \
524 GLint x = span.x, y = YFLIP(xrb, span.y); \
525 for (i = 0; i < span.end; i++, x++) { \
526 const DEPTH_TYPE z = FixedToDepth(span.z); \
528 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \
529 color[GCOMP], color[BCOMP]); \
532 span.z += span.zStep; \
534 #include "swrast/s_tritemp.h"
538 * XImage, smooth, NON-depth-buffered, PF_TRUECOLOR triangle.
540 #define NAME smooth_TRUECOLOR_triangle
543 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
545 XMesaImage *img = xrb->ximage;
546 #define RENDER_SPAN( span ) { \
548 GLint x = span.x, y = YFLIP(xrb, span.y); \
549 for (i = 0; i < span.end; i++, x++) { \
551 PACK_TRUECOLOR(p, FixedToInt(span.red), \
552 FixedToInt(span.green), FixedToInt(span.blue)); \
553 XMesaPutPixel(img, x, y, p); \
554 span.red += span.redStep; \
555 span.green += span.greenStep; \
556 span.blue += span.blueStep; \
558 #include "swrast/s_tritemp.h"
563 * XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle.
565 #define NAME smooth_8A8B8G8R_triangle
567 #define INTERP_ALPHA 1
568 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
569 #define PIXEL_TYPE GLuint
570 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
573 #define RENDER_SPAN( span ) { \
575 for (i = 0; i < span.end; i++) { \
576 pRow[i] = PACK_8A8B8G8R(FixedToInt(span.red), \
577 FixedToInt(span.green), FixedToInt(span.blue), \
578 FixedToInt(span.alpha)); \
579 span.red += span.redStep; \
580 span.green += span.greenStep; \
581 span.blue += span.blueStep; \
582 span.alpha += span.alphaStep; \
584 #include "swrast/s_tritemp.h"
589 * XImage, smooth, NON-depth-buffered, PF_8A8R8G8B triangle.
591 #define NAME smooth_8A8R8G8B_triangle
593 #define INTERP_ALPHA 1
594 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
595 #define PIXEL_TYPE GLuint
596 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
599 #define RENDER_SPAN( span ) { \
601 for (i = 0; i < span.end; i++) { \
602 pRow[i] = PACK_8A8R8G8B(FixedToInt(span.red), \
603 FixedToInt(span.green), FixedToInt(span.blue), \
604 FixedToInt(span.alpha)); \
605 span.red += span.redStep; \
606 span.green += span.greenStep; \
607 span.blue += span.blueStep; \
608 span.alpha += span.alphaStep; \
610 #include "swrast/s_tritemp.h"
615 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
617 #define NAME smooth_8R8G8B_triangle
619 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
620 #define PIXEL_TYPE GLuint
621 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
624 #define RENDER_SPAN( span ) { \
626 for (i = 0; i < span.end; i++) { \
627 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
628 FixedToInt(span.green), FixedToInt(span.blue) ); \
629 span.red += span.redStep; \
630 span.green += span.greenStep; \
631 span.blue += span.blueStep; \
633 #include "swrast/s_tritemp.h"
638 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
640 #define NAME smooth_8R8G8B24_triangle
642 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
643 #define PIXEL_TYPE bgr_t
644 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
647 #define RENDER_SPAN( span ) { \
649 PIXEL_TYPE *pixel = pRow; \
650 for (i = 0; i < span.end; i++, pixel++) { \
651 pixel->r = FixedToInt(span.red); \
652 pixel->g = FixedToInt(span.green); \
653 pixel->b = FixedToInt(span.blue); \
654 span.red += span.redStep; \
655 span.green += span.greenStep; \
656 span.blue += span.blueStep; \
658 #include "swrast/s_tritemp.h"
663 * XImage, smooth, NON-depth-buffered, PF_TRUEDITHER triangle.
665 #define NAME smooth_TRUEDITHER_triangle
668 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
670 XMesaImage *img = xrb->ximage;
671 #define RENDER_SPAN( span ) { \
673 GLint x = span.x, y = YFLIP(xrb, span.y); \
674 for (i = 0; i < span.end; i++, x++) { \
676 PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \
677 FixedToInt(span.green), FixedToInt(span.blue)); \
678 XMesaPutPixel(img, x, y, p ); \
679 span.red += span.redStep; \
680 span.green += span.greenStep; \
681 span.blue += span.blueStep; \
683 #include "swrast/s_tritemp.h"
688 * XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle.
690 #define NAME smooth_5R6G5B_triangle
692 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
693 #define PIXEL_TYPE GLushort
694 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
697 #define RENDER_SPAN( span ) { \
699 for (i = 0; i < span.end; i++) { \
700 pRow[i] = (PIXEL_TYPE) PACK_5R6G5B(FixedToInt(span.red), \
701 FixedToInt(span.green), FixedToInt(span.blue)); \
702 span.red += span.redStep; \
703 span.green += span.greenStep; \
704 span.blue += span.blueStep; \
706 #include "swrast/s_tritemp.h"
711 * XImage, smooth, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
713 #define NAME smooth_DITHER_5R6G5B_triangle
715 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
716 #define PIXEL_TYPE GLushort
717 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
719 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
721 #define RENDER_SPAN( span ) { \
723 GLint x = span.x, y = YFLIP(xrb, span.y); \
724 for (i = 0; i < span.end; i++, x++) { \
725 PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \
726 FixedToInt(span.green), FixedToInt(span.blue)); \
727 span.red += span.redStep; \
728 span.green += span.greenStep; \
729 span.blue += span.blueStep; \
731 #include "swrast/s_tritemp.h"
736 * XImage, flat, NON-depth-buffered, PF_TRUECOLOR triangle.
738 #define NAME flat_TRUECOLOR_triangle
740 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
742 XMesaImage *img = xrb->ximage; \
743 unsigned long pixel; \
744 PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]);
745 #define RENDER_SPAN( span ) { \
747 GLint x = span.x, y = YFLIP(xrb, span.y); \
748 for (i = 0; i < span.end; i++, x++) { \
749 XMesaPutPixel(img, x, y, pixel); \
751 #include "swrast/s_tritemp.h"
756 * XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle.
758 #define NAME flat_8A8B8G8R_triangle
759 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
760 #define PIXEL_TYPE GLuint
761 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
764 unsigned long p = PACK_8B8G8R( v2->color[0], \
765 v2->color[1], v2->color[2] );
766 #define RENDER_SPAN( span ) { \
768 for (i = 0; i < span.end; i++) { \
769 pRow[i] = (PIXEL_TYPE) p; \
771 #include "swrast/s_tritemp.h"
776 * XImage, flat, NON-depth-buffered, PF_8A8R8G8B triangle.
778 #define NAME flat_8A8R8G8B_triangle
779 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
780 #define PIXEL_TYPE GLuint
781 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
784 unsigned long p = PACK_8R8G8B( v2->color[0], \
785 v2->color[1], v2->color[2] );
786 #define RENDER_SPAN( span ) { \
788 for (i = 0; i < span.end; i++) { \
789 pRow[i] = (PIXEL_TYPE) p; \
791 #include "swrast/s_tritemp.h"
796 * XImage, flat, NON-depth-buffered, PF_8R8G8B triangle.
798 #define NAME flat_8R8G8B_triangle
799 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
800 #define PIXEL_TYPE GLuint
801 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
804 unsigned long p = PACK_8R8G8B( v2->color[0], \
805 v2->color[1], v2->color[2] );
806 #define RENDER_SPAN( span ) { \
808 for (i = 0; i < span.end; i++) { \
809 pRow[i] = (PIXEL_TYPE) p; \
811 #include "swrast/s_tritemp.h"
816 * XImage, flat, NON-depth-buffered, PF_8R8G8B24 triangle.
818 #define NAME flat_8R8G8B24_triangle
819 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
820 #define PIXEL_TYPE bgr_t
821 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
824 const GLubyte *color = v2->color;
825 #define RENDER_SPAN( span ) { \
827 PIXEL_TYPE *pixel = pRow; \
828 for (i = 0; i < span.end; i++, pixel++) { \
829 pixel->r = color[RCOMP]; \
830 pixel->g = color[GCOMP]; \
831 pixel->b = color[BCOMP]; \
833 #include "swrast/s_tritemp.h"
838 * XImage, flat, NON-depth-buffered, PF_TRUEDITHER triangle.
840 #define NAME flat_TRUEDITHER_triangle
842 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
844 XMesaImage *img = xrb->ximage;
845 #define RENDER_SPAN( span ) { \
847 GLint x = span.x, y = YFLIP(xrb, span.y); \
848 for (i = 0; i < span.end; i++, x++) { \
850 PACK_TRUEDITHER(p, x, y, v2->color[0], \
851 v2->color[1], v2->color[2] ); \
852 XMesaPutPixel(img, x, y, p); \
854 #include "swrast/s_tritemp.h"
859 * XImage, flat, NON-depth-buffered, PF_5R6G5B triangle.
861 #define NAME flat_5R6G5B_triangle
862 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
863 #define PIXEL_TYPE GLushort
864 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
867 unsigned long p = PACK_5R6G5B( v2->color[0], \
868 v2->color[1], v2->color[2] );
869 #define RENDER_SPAN( span ) { \
871 for (i = 0; i < span.end; i++) { \
872 pRow[i] = (PIXEL_TYPE) p; \
874 #include "swrast/s_tritemp.h"
879 * XImage, flat, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
881 #define NAME flat_DITHER_5R6G5B_triangle
882 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
883 #define PIXEL_TYPE GLushort
884 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
886 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
888 const GLubyte *color = v2->color;
889 #define RENDER_SPAN( span ) { \
891 GLint x = span.x, y = YFLIP(xrb, span.y); \
892 for (i = 0; i < span.end; i++, x++) { \
893 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \
894 color[GCOMP], color[BCOMP]); \
896 #include "swrast/s_tritemp.h"
900 #endif /* CHAN_BITS == 8 */
903 #if defined(DEBUG) && CHAN_BITS == 8
904 extern void _xmesa_print_triangle_func( swrast_tri_func triFunc
);
905 void _xmesa_print_triangle_func( swrast_tri_func triFunc
)
907 printf("XMesa tri func = ");
908 if (triFunc
==smooth_TRUECOLOR_z_triangle
)
909 printf("smooth_TRUECOLOR_z_triangle\n");
910 else if (triFunc
==smooth_8A8B8G8R_z_triangle
)
911 printf("smooth_8A8B8G8R_z_triangle\n");
912 else if (triFunc
==smooth_8A8R8G8B_z_triangle
)
913 printf("smooth_8A8R8G8B_z_triangle\n");
914 else if (triFunc
==smooth_8R8G8B_z_triangle
)
915 printf("smooth_8R8G8B_z_triangle\n");
916 else if (triFunc
==smooth_8R8G8B24_z_triangle
)
917 printf("smooth_8R8G8B24_z_triangle\n");
918 else if (triFunc
==smooth_TRUEDITHER_z_triangle
)
919 printf("smooth_TRUEDITHER_z_triangle\n");
920 else if (triFunc
==smooth_5R6G5B_z_triangle
)
921 printf("smooth_5R6G5B_z_triangle\n");
922 else if (triFunc
==smooth_DITHER_5R6G5B_z_triangle
)
923 printf("smooth_DITHER_5R6G5B_z_triangle\n");
924 else if (triFunc
==flat_TRUECOLOR_z_triangle
)
925 printf("flat_TRUECOLOR_z_triangle\n");
926 else if (triFunc
==flat_8A8B8G8R_z_triangle
)
927 printf("flat_8A8B8G8R_z_triangle\n");
928 else if (triFunc
==flat_8A8R8G8B_z_triangle
)
929 printf("flat_8A8R8G8B_z_triangle\n");
930 else if (triFunc
==flat_8R8G8B_z_triangle
)
931 printf("flat_8R8G8B_z_triangle\n");
932 else if (triFunc
==flat_8R8G8B24_z_triangle
)
933 printf("flat_8R8G8B24_z_triangle\n");
934 else if (triFunc
==flat_TRUEDITHER_z_triangle
)
935 printf("flat_TRUEDITHER_z_triangle\n");
936 else if (triFunc
==flat_5R6G5B_z_triangle
)
937 printf("flat_5R6G5B_z_triangle\n");
938 else if (triFunc
==flat_DITHER_5R6G5B_z_triangle
)
939 printf("flat_DITHER_5R6G5B_z_triangle\n");
940 else if (triFunc
==smooth_TRUECOLOR_triangle
)
941 printf("smooth_TRUECOLOR_triangle\n");
942 else if (triFunc
==smooth_8A8B8G8R_triangle
)
943 printf("smooth_8A8B8G8R_triangle\n");
944 else if (triFunc
==smooth_8A8R8G8B_triangle
)
945 printf("smooth_8A8R8G8B_triangle\n");
946 else if (triFunc
==smooth_8R8G8B_triangle
)
947 printf("smooth_8R8G8B_triangle\n");
948 else if (triFunc
==smooth_8R8G8B24_triangle
)
949 printf("smooth_8R8G8B24_triangle\n");
950 else if (triFunc
==smooth_TRUEDITHER_triangle
)
951 printf("smooth_TRUEDITHER_triangle\n");
952 else if (triFunc
==smooth_5R6G5B_triangle
)
953 printf("smooth_5R6G5B_triangle\n");
954 else if (triFunc
==smooth_DITHER_5R6G5B_triangle
)
955 printf("smooth_DITHER_5R6G5B_triangle\n");
956 else if (triFunc
==flat_TRUECOLOR_triangle
)
957 printf("flat_TRUECOLOR_triangle\n");
958 else if (triFunc
==flat_TRUEDITHER_triangle
)
959 printf("flat_TRUEDITHER_triangle\n");
960 else if (triFunc
==flat_8A8B8G8R_triangle
)
961 printf("flat_8A8B8G8R_triangle\n");
962 else if (triFunc
==flat_8A8R8G8B_triangle
)
963 printf("flat_8A8R8G8B_triangle\n");
964 else if (triFunc
==flat_8R8G8B_triangle
)
965 printf("flat_8R8G8B_triangle\n");
966 else if (triFunc
==flat_8R8G8B24_triangle
)
967 printf("flat_8R8G8B24_triangle\n");
968 else if (triFunc
==flat_5R6G5B_triangle
)
969 printf("flat_5R6G5B_triangle\n");
970 else if (triFunc
==flat_DITHER_5R6G5B_triangle
)
971 printf("flat_DITHER_5R6G5B_triangle\n");
980 /* record the current triangle function name */
981 static const char *triFuncName
= NULL
;
983 #define USE(triFunc) \
985 triFuncName = #triFunc; \
991 #define USE(triFunc) return triFunc
997 * Return pointer to line drawing function, or NULL if we should use a
1000 static swrast_tri_func
1001 get_triangle_func(struct gl_context
*ctx
)
1004 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
1005 XMesaContext xmesa
= XMESA_CONTEXT(ctx
);
1006 const struct xmesa_renderbuffer
*xrb
;
1012 /* trivial fallback tests */
1013 if ((ctx
->DrawBuffer
->_ColorDrawBufferIndexes
[0] != BUFFER_BIT_FRONT_LEFT
) &&
1014 (ctx
->DrawBuffer
->_ColorDrawBufferIndexes
[0] != BUFFER_BIT_BACK_LEFT
))
1015 return (swrast_tri_func
) NULL
;
1016 if (ctx
->RenderMode
!= GL_RENDER
)
1017 return (swrast_tri_func
) NULL
;
1018 if (ctx
->Polygon
.SmoothFlag
)
1019 return (swrast_tri_func
) NULL
;
1020 if (ctx
->Texture
._MaxEnabledTexImageUnit
!= -1)
1021 return (swrast_tri_func
) NULL
;
1022 if (swrast
->_RasterMask
& MULTI_DRAW_BIT
)
1023 return (swrast_tri_func
) NULL
;
1024 if (ctx
->Polygon
.CullFlag
&&
1025 ctx
->Polygon
.CullFaceMode
== GL_FRONT_AND_BACK
)
1026 return (swrast_tri_func
) NULL
;
1028 xrb
= xmesa_renderbuffer(ctx
->DrawBuffer
->_ColorDrawBuffers
[0]);
1031 if ( ctx
->Light
.ShadeModel
==GL_SMOOTH
1032 && swrast
->_RasterMask
==DEPTH_BIT
1033 && ctx
->Depth
.Func
==GL_LESS
1034 && ctx
->Depth
.Mask
==GL_TRUE
1035 && ctx
->Visual
.depthBits
== DEFAULT_SOFTWARE_DEPTH_BITS
1036 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1037 switch (xmesa
->pixelformat
) {
1039 USE(smooth_TRUECOLOR_z_triangle
);
1041 USE(smooth_8A8B8G8R_z_triangle
);
1043 USE(smooth_8A8R8G8B_z_triangle
);
1045 USE(smooth_8R8G8B_z_triangle
);
1047 USE(smooth_8R8G8B24_z_triangle
);
1048 case PF_Dither_True
:
1049 USE(smooth_TRUEDITHER_z_triangle
);
1051 USE(smooth_5R6G5B_z_triangle
);
1052 case PF_Dither_5R6G5B
:
1053 USE(smooth_DITHER_5R6G5B_z_triangle
);
1055 return (swrast_tri_func
) NULL
;
1058 if ( ctx
->Light
.ShadeModel
==GL_FLAT
1059 && swrast
->_RasterMask
==DEPTH_BIT
1060 && ctx
->Depth
.Func
==GL_LESS
1061 && ctx
->Depth
.Mask
==GL_TRUE
1062 && ctx
->Visual
.depthBits
== DEFAULT_SOFTWARE_DEPTH_BITS
1063 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1064 switch (xmesa
->pixelformat
) {
1066 USE(flat_TRUECOLOR_z_triangle
);
1068 USE(flat_8A8B8G8R_z_triangle
);
1070 USE(flat_8A8R8G8B_z_triangle
);
1072 USE(flat_8R8G8B_z_triangle
);
1074 USE(flat_8R8G8B24_z_triangle
);
1075 case PF_Dither_True
:
1076 USE(flat_TRUEDITHER_z_triangle
);
1078 USE(flat_5R6G5B_z_triangle
);
1079 case PF_Dither_5R6G5B
:
1080 USE(flat_DITHER_5R6G5B_z_triangle
);
1082 return (swrast_tri_func
) NULL
;
1085 if ( swrast
->_RasterMask
==0 /* no depth test */
1086 && ctx
->Light
.ShadeModel
==GL_SMOOTH
1087 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1088 switch (xmesa
->pixelformat
) {
1090 USE(smooth_TRUECOLOR_triangle
);
1092 USE(smooth_8A8B8G8R_triangle
);
1094 USE(smooth_8A8R8G8B_triangle
);
1096 USE(smooth_8R8G8B_triangle
);
1098 USE(smooth_8R8G8B24_triangle
);
1099 case PF_Dither_True
:
1100 USE(smooth_TRUEDITHER_triangle
);
1102 USE(smooth_5R6G5B_triangle
);
1103 case PF_Dither_5R6G5B
:
1104 USE(smooth_DITHER_5R6G5B_triangle
);
1106 return (swrast_tri_func
) NULL
;
1110 if ( swrast
->_RasterMask
==0 /* no depth test */
1111 && ctx
->Light
.ShadeModel
==GL_FLAT
1112 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1113 switch (xmesa
->pixelformat
) {
1115 USE(flat_TRUECOLOR_triangle
);
1116 case PF_Dither_True
:
1117 USE(flat_TRUEDITHER_triangle
);
1119 USE(flat_8A8B8G8R_triangle
);
1121 USE(flat_8A8R8G8B_triangle
);
1123 USE(flat_8R8G8B_triangle
);
1125 USE(flat_8R8G8B24_triangle
);
1127 USE(flat_5R6G5B_triangle
);
1128 case PF_Dither_5R6G5B
:
1129 USE(flat_DITHER_5R6G5B_triangle
);
1131 return (swrast_tri_func
) NULL
;
1135 #endif /* CHAN_BITS == 8 */
1137 return (swrast_tri_func
) NULL
;
1141 /* Override for the swrast tri-selection function. Try to use one
1142 * of our internal tri functions, otherwise fall back to the
1143 * standard swrast functions.
1145 void xmesa_choose_triangle( struct gl_context
*ctx
)
1147 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
1149 if (!(swrast
->Triangle
= get_triangle_func( ctx
)))
1150 _swrast_choose_triangle( ctx
);