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.
33 #include "main/imports.h"
34 #include "main/mtypes.h"
35 #include "glxheader.h"
38 /* Internal swrast includes:
40 #include "swrast/s_context.h"
41 #include "swrast/s_depth.h"
42 #include "swrast/s_triangle.h"
45 #define GET_XRB(XRB) struct xmesa_renderbuffer *XRB = \
46 xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0])
49 /**********************************************************************/
50 /*** Triangle rendering ***/
51 /**********************************************************************/
57 * XImage, smooth, depth-buffered, PF_TRUECOLOR triangle.
59 #define NAME smooth_TRUECOLOR_z_triangle
61 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
64 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
67 #define RENDER_SPAN( span ) { \
68 GLint x = span.x, y = YFLIP(xrb, span.y); \
70 for (i = 0; i < span.end; i++, x++) { \
71 const DEPTH_TYPE z = FixedToDepth(span.z); \
74 PACK_TRUECOLOR(p, FixedToInt(span.red), \
75 FixedToInt(span.green), FixedToInt(span.blue)); \
76 XMesaPutPixel(xrb->ximage, x, y, p); \
79 span.red += span.redStep; \
80 span.green += span.greenStep; \
81 span.blue += span.blueStep; \
82 span.z += span.zStep; \
85 #include "swrast/s_tritemp.h"
91 * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle.
93 #define NAME smooth_8A8B8G8R_z_triangle
95 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
97 #define INTERP_ALPHA 1
98 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
99 #define PIXEL_TYPE GLuint
100 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
103 #define RENDER_SPAN( span ) { \
105 for (i = 0; i < span.end; i++) { \
106 const DEPTH_TYPE z = FixedToDepth(span.z); \
108 pRow[i] = PACK_8A8B8G8R(FixedToInt(span.red), \
109 FixedToInt(span.green), FixedToInt(span.blue), \
110 FixedToInt(span.alpha)); \
113 span.red += span.redStep; \
114 span.green += span.greenStep; \
115 span.blue += span.blueStep; \
116 span.alpha += span.alphaStep; \
117 span.z += span.zStep; \
120 #include "swrast/s_tritemp.h"
125 * XImage, smooth, depth-buffered, PF_8A8R8G8B triangle.
127 #define NAME smooth_8A8R8G8B_z_triangle
129 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
131 #define INTERP_ALPHA 1
132 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
133 #define PIXEL_TYPE GLuint
134 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
138 #define RENDER_SPAN( span ) { \
140 for (i = 0; i < span.end; i++) { \
141 const DEPTH_TYPE z = FixedToDepth(span.z); \
143 pRow[i] = PACK_8A8R8G8B(FixedToInt(span.red), \
144 FixedToInt(span.green), FixedToInt(span.blue), \
145 FixedToInt(span.alpha)); \
148 span.red += span.redStep; \
149 span.green += span.greenStep; \
150 span.blue += span.blueStep; \
151 span.alpha += span.alphaStep; \
152 span.z += span.zStep; \
155 #include "swrast/s_tritemp.h"
160 * XImage, smooth, depth-buffered, PF_8R8G8B triangle.
162 #define NAME smooth_8R8G8B_z_triangle
164 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
166 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
167 #define PIXEL_TYPE GLuint
168 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
172 #define RENDER_SPAN( span ) { \
174 for (i = 0; i < span.end; i++) { \
175 const DEPTH_TYPE z = FixedToDepth(span.z); \
177 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
178 FixedToInt(span.green), FixedToInt(span.blue)); \
181 span.red += span.redStep; \
182 span.green += span.greenStep; \
183 span.blue += span.blueStep; \
184 span.z += span.zStep; \
187 #include "swrast/s_tritemp.h"
192 * XImage, smooth, depth-buffered, PF_8R8G8B24 triangle.
194 #define NAME smooth_8R8G8B24_z_triangle
196 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
198 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
199 #define PIXEL_TYPE bgr_t
200 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
203 #define RENDER_SPAN( span ) { \
205 for (i = 0; i < span.end; i++) { \
206 const DEPTH_TYPE z = FixedToDepth(span.z); \
208 PIXEL_TYPE *ptr = pRow + i; \
209 ptr->r = FixedToInt(span.red); \
210 ptr->g = FixedToInt(span.green); \
211 ptr->b = FixedToInt(span.blue); \
214 span.red += span.redStep; \
215 span.green += span.greenStep; \
216 span.blue += span.blueStep; \
217 span.z += span.zStep; \
219 #include "swrast/s_tritemp.h"
224 * XImage, smooth, depth-buffered, PF_TRUEDITHER triangle.
226 #define NAME smooth_TRUEDITHER_z_triangle
228 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
231 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
233 #define RENDER_SPAN( span ) { \
235 GLint x = span.x, y = YFLIP(xrb, span.y); \
236 for (i = 0; i < span.end; i++, x++) { \
237 const DEPTH_TYPE z = FixedToDepth(span.z); \
240 PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \
241 FixedToInt(span.green), FixedToInt(span.blue)); \
242 XMesaPutPixel(xrb->ximage, x, y, p); \
245 span.red += span.redStep; \
246 span.green += span.greenStep; \
247 span.blue += span.blueStep; \
248 span.z += span.zStep; \
250 #include "swrast/s_tritemp.h"
255 * XImage, smooth, depth-buffered, PF_5R6G5B triangle.
257 #define NAME smooth_5R6G5B_z_triangle
259 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
261 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
262 #define PIXEL_TYPE GLushort
263 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
266 #define RENDER_SPAN( span ) { \
268 for (i = 0; i < span.end; i++) { \
269 const DEPTH_TYPE z = FixedToDepth(span.z); \
271 pRow[i] = PACK_5R6G5B(FixedToInt(span.red), \
272 FixedToInt(span.green), FixedToInt(span.blue)); \
275 span.red += span.redStep; \
276 span.green += span.greenStep; \
277 span.blue += span.blueStep; \
278 span.z += span.zStep; \
280 #include "swrast/s_tritemp.h"
285 * XImage, smooth, depth-buffered, PF_DITHER_5R6G5B triangle.
287 #define NAME smooth_DITHER_5R6G5B_z_triangle
289 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
291 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
292 #define PIXEL_TYPE GLushort
293 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
295 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
297 #define RENDER_SPAN( span ) { \
299 GLint x = span.x, y = YFLIP(xrb, span.y); \
300 for (i = 0; i < span.end; i++, x++) { \
301 const DEPTH_TYPE z = FixedToDepth(span.z); \
303 PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \
304 FixedToInt(span.green), FixedToInt(span.blue)); \
307 span.red += span.redStep; \
308 span.green += span.greenStep; \
309 span.blue += span.blueStep; \
310 span.z += span.zStep; \
312 #include "swrast/s_tritemp.h"
317 * XImage, flat, depth-buffered, PF_TRUECOLOR triangle.
319 #define NAME flat_TRUECOLOR_z_triangle
321 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
323 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
325 XMesaImage *img = xrb->ximage; \
326 unsigned long pixel; \
327 PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]);
328 #define RENDER_SPAN( span ) { \
330 GLint x = span.x, y = YFLIP(xrb, span.y); \
331 for (i = 0; i < span.end; i++, x++) { \
332 const DEPTH_TYPE z = FixedToDepth(span.z); \
334 XMesaPutPixel(img, x, y, pixel); \
337 span.z += span.zStep; \
339 #include "swrast/s_tritemp.h"
344 * XImage, flat, depth-buffered, PF_8A8B8G8R triangle.
346 #define NAME flat_8A8B8G8R_z_triangle
348 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
349 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
350 #define PIXEL_TYPE GLuint
351 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
354 GLuint p = PACK_8A8B8G8R( v2->color[0], v2->color[1],\
355 v2->color[2], v2->color[3]);
356 #define RENDER_SPAN( span ) { \
358 for (i = 0; i < span.end; i++) { \
359 const DEPTH_TYPE z = FixedToDepth(span.z); \
361 pRow[i] = (PIXEL_TYPE) p; \
364 span.z += span.zStep; \
366 #include "swrast/s_tritemp.h"
371 * XImage, flat, depth-buffered, PF_8A8R8G8B triangle.
373 #define NAME flat_8A8R8G8B_z_triangle
375 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
376 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
377 #define PIXEL_TYPE GLuint
378 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
381 GLuint p = PACK_8A8R8G8B(v2->color[0], v2->color[1], \
382 v2->color[2], v2->color[3]);
383 #define RENDER_SPAN( span ) { \
385 for (i = 0; i < span.end; i++) { \
386 const DEPTH_TYPE z = FixedToDepth(span.z); \
388 pRow[i] = (PIXEL_TYPE) p; \
391 span.z += span.zStep; \
393 #include "swrast/s_tritemp.h"
398 * XImage, flat, depth-buffered, PF_8R8G8B triangle.
400 #define NAME flat_8R8G8B_z_triangle
402 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
403 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
404 #define PIXEL_TYPE GLuint
405 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
408 GLuint p = PACK_8R8G8B( v2->color[0], v2->color[1], v2->color[2] );
409 #define RENDER_SPAN( span ) { \
411 for (i = 0; i < span.end; i++) { \
412 DEPTH_TYPE z = FixedToDepth(span.z); \
414 pRow[i] = (PIXEL_TYPE) p; \
417 span.z += span.zStep; \
420 #include "swrast/s_tritemp.h"
425 * XImage, flat, depth-buffered, PF_8R8G8B24 triangle.
427 #define NAME flat_8R8G8B24_z_triangle
429 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
430 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
431 #define PIXEL_TYPE bgr_t
432 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
435 const GLubyte *color = v2->color;
436 #define RENDER_SPAN( span ) { \
438 for (i = 0; i < span.end; i++) { \
439 const DEPTH_TYPE z = FixedToDepth(span.z); \
441 PIXEL_TYPE *ptr = pRow + i; \
442 ptr->r = color[RCOMP]; \
443 ptr->g = color[GCOMP]; \
444 ptr->b = color[BCOMP]; \
447 span.z += span.zStep; \
449 #include "swrast/s_tritemp.h"
454 * XImage, flat, depth-buffered, PF_TRUEDITHER triangle.
456 #define NAME flat_TRUEDITHER_z_triangle
458 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
460 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
462 XMesaImage *img = xrb->ximage;
463 #define RENDER_SPAN( span ) { \
465 GLint x = span.x, y = YFLIP(xrb, span.y); \
466 for (i = 0; i < span.end; i++, x++) { \
467 const DEPTH_TYPE z = FixedToDepth(span.z); \
470 PACK_TRUEDITHER(p, x, y, v2->color[0], \
471 v2->color[1], v2->color[2]); \
472 XMesaPutPixel(img, x, y, p); \
475 span.z += span.zStep; \
477 #include "swrast/s_tritemp.h"
482 * XImage, flat, depth-buffered, PF_5R6G5B triangle.
484 #define NAME flat_5R6G5B_z_triangle
486 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
487 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
488 #define PIXEL_TYPE GLushort
489 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
492 GLushort p = PACK_5R6G5B( v2->color[0], v2->color[1], v2->color[2] );
493 #define RENDER_SPAN( span ) { \
495 for (i = 0; i < span.end; i++) { \
496 const DEPTH_TYPE z = FixedToDepth(span.z); \
498 pRow[i] = (PIXEL_TYPE) p; \
501 span.z += span.zStep; \
503 #include "swrast/s_tritemp.h"
508 * XImage, flat, depth-buffered, PF_DITHER_5R6G5B triangle.
510 #define NAME flat_DITHER_5R6G5B_z_triangle
512 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
513 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
514 #define PIXEL_TYPE GLushort
515 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
517 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
519 const GLubyte *color = v2->color;
520 #define RENDER_SPAN( span ) { \
522 GLint x = span.x, y = YFLIP(xrb, span.y); \
523 for (i = 0; i < span.end; i++, x++) { \
524 const DEPTH_TYPE z = FixedToDepth(span.z); \
526 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \
527 color[GCOMP], color[BCOMP]); \
530 span.z += span.zStep; \
532 #include "swrast/s_tritemp.h"
536 * XImage, smooth, NON-depth-buffered, PF_TRUECOLOR triangle.
538 #define NAME smooth_TRUECOLOR_triangle
541 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
543 XMesaImage *img = xrb->ximage;
544 #define RENDER_SPAN( span ) { \
546 GLint x = span.x, y = YFLIP(xrb, span.y); \
547 for (i = 0; i < span.end; i++, x++) { \
549 PACK_TRUECOLOR(p, FixedToInt(span.red), \
550 FixedToInt(span.green), FixedToInt(span.blue)); \
551 XMesaPutPixel(img, x, y, p); \
552 span.red += span.redStep; \
553 span.green += span.greenStep; \
554 span.blue += span.blueStep; \
556 #include "swrast/s_tritemp.h"
561 * XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle.
563 #define NAME smooth_8A8B8G8R_triangle
565 #define INTERP_ALPHA 1
566 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
567 #define PIXEL_TYPE GLuint
568 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
571 #define RENDER_SPAN( span ) { \
573 for (i = 0; i < span.end; i++) { \
574 pRow[i] = PACK_8A8B8G8R(FixedToInt(span.red), \
575 FixedToInt(span.green), FixedToInt(span.blue), \
576 FixedToInt(span.alpha)); \
577 span.red += span.redStep; \
578 span.green += span.greenStep; \
579 span.blue += span.blueStep; \
580 span.alpha += span.alphaStep; \
582 #include "swrast/s_tritemp.h"
587 * XImage, smooth, NON-depth-buffered, PF_8A8R8G8B triangle.
589 #define NAME smooth_8A8R8G8B_triangle
591 #define INTERP_ALPHA 1
592 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
593 #define PIXEL_TYPE GLuint
594 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
597 #define RENDER_SPAN( span ) { \
599 for (i = 0; i < span.end; i++) { \
600 pRow[i] = PACK_8A8R8G8B(FixedToInt(span.red), \
601 FixedToInt(span.green), FixedToInt(span.blue), \
602 FixedToInt(span.alpha)); \
603 span.red += span.redStep; \
604 span.green += span.greenStep; \
605 span.blue += span.blueStep; \
606 span.alpha += span.alphaStep; \
608 #include "swrast/s_tritemp.h"
613 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
615 #define NAME smooth_8R8G8B_triangle
617 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
618 #define PIXEL_TYPE GLuint
619 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
622 #define RENDER_SPAN( span ) { \
624 for (i = 0; i < span.end; i++) { \
625 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
626 FixedToInt(span.green), FixedToInt(span.blue) ); \
627 span.red += span.redStep; \
628 span.green += span.greenStep; \
629 span.blue += span.blueStep; \
631 #include "swrast/s_tritemp.h"
636 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
638 #define NAME smooth_8R8G8B24_triangle
640 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
641 #define PIXEL_TYPE bgr_t
642 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
645 #define RENDER_SPAN( span ) { \
647 PIXEL_TYPE *pixel = pRow; \
648 for (i = 0; i < span.end; i++, pixel++) { \
649 pixel->r = FixedToInt(span.red); \
650 pixel->g = FixedToInt(span.green); \
651 pixel->b = FixedToInt(span.blue); \
652 span.red += span.redStep; \
653 span.green += span.greenStep; \
654 span.blue += span.blueStep; \
656 #include "swrast/s_tritemp.h"
661 * XImage, smooth, NON-depth-buffered, PF_TRUEDITHER triangle.
663 #define NAME smooth_TRUEDITHER_triangle
666 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
668 XMesaImage *img = xrb->ximage;
669 #define RENDER_SPAN( span ) { \
671 GLint x = span.x, y = YFLIP(xrb, span.y); \
672 for (i = 0; i < span.end; i++, x++) { \
674 PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \
675 FixedToInt(span.green), FixedToInt(span.blue)); \
676 XMesaPutPixel(img, x, y, p ); \
677 span.red += span.redStep; \
678 span.green += span.greenStep; \
679 span.blue += span.blueStep; \
681 #include "swrast/s_tritemp.h"
686 * XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle.
688 #define NAME smooth_5R6G5B_triangle
690 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
691 #define PIXEL_TYPE GLushort
692 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
695 #define RENDER_SPAN( span ) { \
697 for (i = 0; i < span.end; i++) { \
698 pRow[i] = (PIXEL_TYPE) PACK_5R6G5B(FixedToInt(span.red), \
699 FixedToInt(span.green), FixedToInt(span.blue)); \
700 span.red += span.redStep; \
701 span.green += span.greenStep; \
702 span.blue += span.blueStep; \
704 #include "swrast/s_tritemp.h"
709 * XImage, smooth, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
711 #define NAME smooth_DITHER_5R6G5B_triangle
713 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
714 #define PIXEL_TYPE GLushort
715 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
717 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
719 #define RENDER_SPAN( span ) { \
721 GLint x = span.x, y = YFLIP(xrb, span.y); \
722 for (i = 0; i < span.end; i++, x++) { \
723 PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \
724 FixedToInt(span.green), FixedToInt(span.blue)); \
725 span.red += span.redStep; \
726 span.green += span.greenStep; \
727 span.blue += span.blueStep; \
729 #include "swrast/s_tritemp.h"
734 * XImage, flat, NON-depth-buffered, PF_TRUECOLOR triangle.
736 #define NAME flat_TRUECOLOR_triangle
738 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
740 XMesaImage *img = xrb->ximage; \
741 unsigned long pixel; \
742 PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]);
743 #define RENDER_SPAN( span ) { \
745 GLint x = span.x, y = YFLIP(xrb, span.y); \
746 for (i = 0; i < span.end; i++, x++) { \
747 XMesaPutPixel(img, x, y, pixel); \
749 #include "swrast/s_tritemp.h"
754 * XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle.
756 #define NAME flat_8A8B8G8R_triangle
757 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
758 #define PIXEL_TYPE GLuint
759 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
762 unsigned long p = PACK_8B8G8R( v2->color[0], \
763 v2->color[1], v2->color[2] );
764 #define RENDER_SPAN( span ) { \
766 for (i = 0; i < span.end; i++) { \
767 pRow[i] = (PIXEL_TYPE) p; \
769 #include "swrast/s_tritemp.h"
774 * XImage, flat, NON-depth-buffered, PF_8A8R8G8B triangle.
776 #define NAME flat_8A8R8G8B_triangle
777 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
778 #define PIXEL_TYPE GLuint
779 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
782 unsigned long p = PACK_8R8G8B( v2->color[0], \
783 v2->color[1], v2->color[2] );
784 #define RENDER_SPAN( span ) { \
786 for (i = 0; i < span.end; i++) { \
787 pRow[i] = (PIXEL_TYPE) p; \
789 #include "swrast/s_tritemp.h"
794 * XImage, flat, NON-depth-buffered, PF_8R8G8B triangle.
796 #define NAME flat_8R8G8B_triangle
797 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
798 #define PIXEL_TYPE GLuint
799 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
802 unsigned long p = PACK_8R8G8B( v2->color[0], \
803 v2->color[1], v2->color[2] );
804 #define RENDER_SPAN( span ) { \
806 for (i = 0; i < span.end; i++) { \
807 pRow[i] = (PIXEL_TYPE) p; \
809 #include "swrast/s_tritemp.h"
814 * XImage, flat, NON-depth-buffered, PF_8R8G8B24 triangle.
816 #define NAME flat_8R8G8B24_triangle
817 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
818 #define PIXEL_TYPE bgr_t
819 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
822 const GLubyte *color = v2->color;
823 #define RENDER_SPAN( span ) { \
825 PIXEL_TYPE *pixel = pRow; \
826 for (i = 0; i < span.end; i++, pixel++) { \
827 pixel->r = color[RCOMP]; \
828 pixel->g = color[GCOMP]; \
829 pixel->b = color[BCOMP]; \
831 #include "swrast/s_tritemp.h"
836 * XImage, flat, NON-depth-buffered, PF_TRUEDITHER triangle.
838 #define NAME flat_TRUEDITHER_triangle
840 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
842 XMesaImage *img = xrb->ximage;
843 #define RENDER_SPAN( span ) { \
845 GLint x = span.x, y = YFLIP(xrb, span.y); \
846 for (i = 0; i < span.end; i++, x++) { \
848 PACK_TRUEDITHER(p, x, y, v2->color[0], \
849 v2->color[1], v2->color[2] ); \
850 XMesaPutPixel(img, x, y, p); \
852 #include "swrast/s_tritemp.h"
857 * XImage, flat, NON-depth-buffered, PF_5R6G5B triangle.
859 #define NAME flat_5R6G5B_triangle
860 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
861 #define PIXEL_TYPE GLushort
862 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
865 unsigned long p = PACK_5R6G5B( v2->color[0], \
866 v2->color[1], v2->color[2] );
867 #define RENDER_SPAN( span ) { \
869 for (i = 0; i < span.end; i++) { \
870 pRow[i] = (PIXEL_TYPE) p; \
872 #include "swrast/s_tritemp.h"
877 * XImage, flat, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
879 #define NAME flat_DITHER_5R6G5B_triangle
880 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
881 #define PIXEL_TYPE GLushort
882 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
884 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
886 const GLubyte *color = v2->color;
887 #define RENDER_SPAN( span ) { \
889 GLint x = span.x, y = YFLIP(xrb, span.y); \
890 for (i = 0; i < span.end; i++, x++) { \
891 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \
892 color[GCOMP], color[BCOMP]); \
894 #include "swrast/s_tritemp.h"
898 #endif /* CHAN_BITS == 8 */
901 #if defined(DEBUG) && CHAN_BITS == 8
902 extern void _xmesa_print_triangle_func( swrast_tri_func triFunc
);
903 void _xmesa_print_triangle_func( swrast_tri_func triFunc
)
905 printf("XMesa tri func = ");
906 if (triFunc
==smooth_TRUECOLOR_z_triangle
)
907 printf("smooth_TRUECOLOR_z_triangle\n");
908 else if (triFunc
==smooth_8A8B8G8R_z_triangle
)
909 printf("smooth_8A8B8G8R_z_triangle\n");
910 else if (triFunc
==smooth_8A8R8G8B_z_triangle
)
911 printf("smooth_8A8R8G8B_z_triangle\n");
912 else if (triFunc
==smooth_8R8G8B_z_triangle
)
913 printf("smooth_8R8G8B_z_triangle\n");
914 else if (triFunc
==smooth_8R8G8B24_z_triangle
)
915 printf("smooth_8R8G8B24_z_triangle\n");
916 else if (triFunc
==smooth_TRUEDITHER_z_triangle
)
917 printf("smooth_TRUEDITHER_z_triangle\n");
918 else if (triFunc
==smooth_5R6G5B_z_triangle
)
919 printf("smooth_5R6G5B_z_triangle\n");
920 else if (triFunc
==smooth_DITHER_5R6G5B_z_triangle
)
921 printf("smooth_DITHER_5R6G5B_z_triangle\n");
922 else if (triFunc
==flat_TRUECOLOR_z_triangle
)
923 printf("flat_TRUECOLOR_z_triangle\n");
924 else if (triFunc
==flat_8A8B8G8R_z_triangle
)
925 printf("flat_8A8B8G8R_z_triangle\n");
926 else if (triFunc
==flat_8A8R8G8B_z_triangle
)
927 printf("flat_8A8R8G8B_z_triangle\n");
928 else if (triFunc
==flat_8R8G8B_z_triangle
)
929 printf("flat_8R8G8B_z_triangle\n");
930 else if (triFunc
==flat_8R8G8B24_z_triangle
)
931 printf("flat_8R8G8B24_z_triangle\n");
932 else if (triFunc
==flat_TRUEDITHER_z_triangle
)
933 printf("flat_TRUEDITHER_z_triangle\n");
934 else if (triFunc
==flat_5R6G5B_z_triangle
)
935 printf("flat_5R6G5B_z_triangle\n");
936 else if (triFunc
==flat_DITHER_5R6G5B_z_triangle
)
937 printf("flat_DITHER_5R6G5B_z_triangle\n");
938 else if (triFunc
==smooth_TRUECOLOR_triangle
)
939 printf("smooth_TRUECOLOR_triangle\n");
940 else if (triFunc
==smooth_8A8B8G8R_triangle
)
941 printf("smooth_8A8B8G8R_triangle\n");
942 else if (triFunc
==smooth_8A8R8G8B_triangle
)
943 printf("smooth_8A8R8G8B_triangle\n");
944 else if (triFunc
==smooth_8R8G8B_triangle
)
945 printf("smooth_8R8G8B_triangle\n");
946 else if (triFunc
==smooth_8R8G8B24_triangle
)
947 printf("smooth_8R8G8B24_triangle\n");
948 else if (triFunc
==smooth_TRUEDITHER_triangle
)
949 printf("smooth_TRUEDITHER_triangle\n");
950 else if (triFunc
==smooth_5R6G5B_triangle
)
951 printf("smooth_5R6G5B_triangle\n");
952 else if (triFunc
==smooth_DITHER_5R6G5B_triangle
)
953 printf("smooth_DITHER_5R6G5B_triangle\n");
954 else if (triFunc
==flat_TRUECOLOR_triangle
)
955 printf("flat_TRUECOLOR_triangle\n");
956 else if (triFunc
==flat_TRUEDITHER_triangle
)
957 printf("flat_TRUEDITHER_triangle\n");
958 else if (triFunc
==flat_8A8B8G8R_triangle
)
959 printf("flat_8A8B8G8R_triangle\n");
960 else if (triFunc
==flat_8A8R8G8B_triangle
)
961 printf("flat_8A8R8G8B_triangle\n");
962 else if (triFunc
==flat_8R8G8B_triangle
)
963 printf("flat_8R8G8B_triangle\n");
964 else if (triFunc
==flat_8R8G8B24_triangle
)
965 printf("flat_8R8G8B24_triangle\n");
966 else if (triFunc
==flat_5R6G5B_triangle
)
967 printf("flat_5R6G5B_triangle\n");
968 else if (triFunc
==flat_DITHER_5R6G5B_triangle
)
969 printf("flat_DITHER_5R6G5B_triangle\n");
978 /* record the current triangle function name */
979 static const char *triFuncName
= NULL
;
981 #define USE(triFunc) \
983 triFuncName = #triFunc; \
989 #define USE(triFunc) return triFunc
995 * Return pointer to line drawing function, or NULL if we should use a
998 static swrast_tri_func
999 get_triangle_func(struct gl_context
*ctx
)
1002 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
1003 XMesaContext xmesa
= XMESA_CONTEXT(ctx
);
1004 const struct xmesa_renderbuffer
*xrb
;
1010 /* trivial fallback tests */
1011 if ((ctx
->DrawBuffer
->_ColorDrawBufferIndexes
[0] != BUFFER_BIT_FRONT_LEFT
) &&
1012 (ctx
->DrawBuffer
->_ColorDrawBufferIndexes
[0] != BUFFER_BIT_BACK_LEFT
))
1013 return (swrast_tri_func
) NULL
;
1014 if (ctx
->RenderMode
!= GL_RENDER
)
1015 return (swrast_tri_func
) NULL
;
1016 if (ctx
->Polygon
.SmoothFlag
)
1017 return (swrast_tri_func
) NULL
;
1018 if (ctx
->Texture
._EnabledUnits
)
1019 return (swrast_tri_func
) NULL
;
1020 if (swrast
->_RasterMask
& MULTI_DRAW_BIT
)
1021 return (swrast_tri_func
) NULL
;
1022 if (ctx
->Polygon
.CullFlag
&&
1023 ctx
->Polygon
.CullFaceMode
== GL_FRONT_AND_BACK
)
1024 return (swrast_tri_func
) NULL
;
1026 xrb
= xmesa_renderbuffer(ctx
->DrawBuffer
->_ColorDrawBuffers
[0]);
1029 if ( ctx
->Light
.ShadeModel
==GL_SMOOTH
1030 && swrast
->_RasterMask
==DEPTH_BIT
1031 && ctx
->Depth
.Func
==GL_LESS
1032 && ctx
->Depth
.Mask
==GL_TRUE
1033 && ctx
->Visual
.depthBits
== DEFAULT_SOFTWARE_DEPTH_BITS
1034 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1035 switch (xmesa
->pixelformat
) {
1037 USE(smooth_TRUECOLOR_z_triangle
);
1039 USE(smooth_8A8B8G8R_z_triangle
);
1041 USE(smooth_8A8R8G8B_z_triangle
);
1043 USE(smooth_8R8G8B_z_triangle
);
1045 USE(smooth_8R8G8B24_z_triangle
);
1046 case PF_Dither_True
:
1047 USE(smooth_TRUEDITHER_z_triangle
);
1049 USE(smooth_5R6G5B_z_triangle
);
1050 case PF_Dither_5R6G5B
:
1051 USE(smooth_DITHER_5R6G5B_z_triangle
);
1053 return (swrast_tri_func
) NULL
;
1056 if ( ctx
->Light
.ShadeModel
==GL_FLAT
1057 && swrast
->_RasterMask
==DEPTH_BIT
1058 && ctx
->Depth
.Func
==GL_LESS
1059 && ctx
->Depth
.Mask
==GL_TRUE
1060 && ctx
->Visual
.depthBits
== DEFAULT_SOFTWARE_DEPTH_BITS
1061 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1062 switch (xmesa
->pixelformat
) {
1064 USE(flat_TRUECOLOR_z_triangle
);
1066 USE(flat_8A8B8G8R_z_triangle
);
1068 USE(flat_8A8R8G8B_z_triangle
);
1070 USE(flat_8R8G8B_z_triangle
);
1072 USE(flat_8R8G8B24_z_triangle
);
1073 case PF_Dither_True
:
1074 USE(flat_TRUEDITHER_z_triangle
);
1076 USE(flat_5R6G5B_z_triangle
);
1077 case PF_Dither_5R6G5B
:
1078 USE(flat_DITHER_5R6G5B_z_triangle
);
1080 return (swrast_tri_func
) NULL
;
1083 if ( swrast
->_RasterMask
==0 /* no depth test */
1084 && ctx
->Light
.ShadeModel
==GL_SMOOTH
1085 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1086 switch (xmesa
->pixelformat
) {
1088 USE(smooth_TRUECOLOR_triangle
);
1090 USE(smooth_8A8B8G8R_triangle
);
1092 USE(smooth_8A8R8G8B_triangle
);
1094 USE(smooth_8R8G8B_triangle
);
1096 USE(smooth_8R8G8B24_triangle
);
1097 case PF_Dither_True
:
1098 USE(smooth_TRUEDITHER_triangle
);
1100 USE(smooth_5R6G5B_triangle
);
1101 case PF_Dither_5R6G5B
:
1102 USE(smooth_DITHER_5R6G5B_triangle
);
1104 return (swrast_tri_func
) NULL
;
1108 if ( swrast
->_RasterMask
==0 /* no depth test */
1109 && ctx
->Light
.ShadeModel
==GL_FLAT
1110 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1111 switch (xmesa
->pixelformat
) {
1113 USE(flat_TRUECOLOR_triangle
);
1114 case PF_Dither_True
:
1115 USE(flat_TRUEDITHER_triangle
);
1117 USE(flat_8A8B8G8R_triangle
);
1119 USE(flat_8A8R8G8B_triangle
);
1121 USE(flat_8R8G8B_triangle
);
1123 USE(flat_8R8G8B24_triangle
);
1125 USE(flat_5R6G5B_triangle
);
1126 case PF_Dither_5R6G5B
:
1127 USE(flat_DITHER_5R6G5B_triangle
);
1129 return (swrast_tri_func
) NULL
;
1133 #endif /* CHAN_BITS == 8 */
1135 return (swrast_tri_func
) NULL
;
1139 /* Override for the swrast tri-selection function. Try to use one
1140 * of our internal tri functions, otherwise fall back to the
1141 * standard swrast functions.
1143 void xmesa_choose_triangle( struct gl_context
*ctx
)
1145 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
1147 if (!(swrast
->Triangle
= get_triangle_func( ctx
)))
1148 _swrast_choose_triangle( ctx
);