1 /* $Id: xm_tri.c,v 1.1 2000/09/07 15:40:30 brianp Exp $ */
4 * Mesa 3-D graphics library
7 * Copyright (C) 1999 Brian Paul All Rights Reserved.
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 * This file contains "accelerated" triangle functions. It should be
30 * fairly easy to write new special-purpose triangle functions and hook
31 * them into this module.
35 #include "glxheader.h"
45 /**********************************************************************/
46 /*** Triangle rendering ***/
47 /**********************************************************************/
52 * Render a triangle into a pixmap, any pixel format, flat shaded and
55 static void flat_pixmap_triangle( GLcontext
*ctx
,
56 GLuint v0
, GLuint v1
, GLuint v2
, GLuint pv
)
58 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
59 struct vertex_buffer
*VB
= ctx
->VB
;
63 if (0 /*VB->MonoColor*/) {
64 gc
= xmesa
->xm_buffer
->gc1
; /* use current color */
68 if (xmesa
->xm_visual
->gl_visual
->RGBAflag
) {
69 pixel
= xmesa_color_to_pixel( xmesa
,
70 VB
->ColorPtr
->data
[pv
][0], VB
->ColorPtr
->data
[pv
][1],
71 VB
->ColorPtr
->data
[pv
][2], VB
->ColorPtr
->data
[pv
][3],
75 pixel
= VB
->IndexPtr
->data
[pv
];
77 gc
= xmesa
->xm_buffer
->gc2
;
78 XMesaSetForeground( xmesa
->display
, gc
, pixel
);
80 p
[0].x
= (GLint
) (VB
->Win
.data
[v0
][0] + 0.5f
);
81 p
[0].y
= FLIP( xmesa
->xm_buffer
, (GLint
) (VB
->Win
.data
[v0
][1] - 0.5f
) );
82 p
[1].x
= (GLint
) (VB
->Win
.data
[v1
][0] + 0.5f
);
83 p
[1].y
= FLIP( xmesa
->xm_buffer
, (GLint
) (VB
->Win
.data
[v1
][1] - 0.5f
) );
84 p
[2].x
= (GLint
) (VB
->Win
.data
[v2
][0] + 0.5f
);
85 p
[2].y
= FLIP( xmesa
->xm_buffer
, (GLint
) (VB
->Win
.data
[v2
][1] - 0.5f
) );
86 XMesaFillPolygon( xmesa
->display
, xmesa
->xm_buffer
->buffer
, gc
,
87 p
, 3, Convex
, CoordModeOrigin
);
93 * XImage, smooth, depth-buffered, PF_TRUECOLOR triangle.
95 static void smooth_TRUECOLOR_z_triangle( GLcontext
*ctx
,
96 GLuint v0
, GLuint v1
, GLuint v2
,
99 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
100 XMesaImage
*img
= xmesa
->xm_buffer
->backimage
;
103 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
105 #define INNER_LOOP( LEFT, RIGHT, Y ) \
107 GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer, Y); \
108 GLint len = RIGHT-LEFT; \
109 for (i=0;i<len;i++,xx++) { \
110 GLdepth z = FixedToDepth(ffz); \
113 PACK_TRUECOLOR(p, FixedToInt(ffr), FixedToInt(ffg), FixedToInt(ffb));\
114 XMesaPutPixel( img, xx, yy, p ); \
117 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
127 * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle.
129 static void smooth_8A8B8G8R_z_triangle( GLcontext
*ctx
,
130 GLuint v0
, GLuint v1
, GLuint v2
,
133 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
136 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
138 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
139 #define PIXEL_TYPE GLuint
140 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
141 #define INNER_LOOP( LEFT, RIGHT, Y ) \
143 GLint i, len = RIGHT-LEFT; \
144 for (i=0;i<len;i++) { \
145 GLdepth z = FixedToDepth(ffz); \
147 pRow[i] = PACK_8B8G8R( FixedToInt(ffr), FixedToInt(ffg), \
151 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
160 * XImage, smooth, depth-buffered, PF_8R8G8B triangle.
162 static void smooth_8R8G8B_z_triangle( GLcontext
*ctx
,
163 GLuint v0
, GLuint v1
, GLuint v2
,
166 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
169 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
171 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
172 #define PIXEL_TYPE GLuint
173 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
174 #define INNER_LOOP( LEFT, RIGHT, Y ) \
176 GLint i, len = RIGHT-LEFT; \
177 for (i=0;i<len;i++) { \
178 GLdepth z = FixedToDepth(ffz); \
180 pRow[i] = PACK_8R8G8B( FixedToInt(ffr), FixedToInt(ffg), \
184 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
193 * XImage, smooth, depth-buffered, PF_8R8G8B24 triangle.
195 static void smooth_8R8G8B24_z_triangle( GLcontext
*ctx
,
196 GLuint v0
, GLuint v1
, GLuint v2
,
199 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
202 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
204 #define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
205 #define PIXEL_TYPE bgr_t
206 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
207 #define INNER_LOOP( LEFT, RIGHT, Y ) \
209 GLint i, len = RIGHT-LEFT; \
210 for (i=0;i<len;i++) { \
211 GLdepth z = FixedToDepth(ffz); \
213 PIXEL_TYPE *ptr = pRow + i; \
214 ptr->r = FixedToInt(ffr); \
215 ptr->g = FixedToInt(ffg); \
216 ptr->b = FixedToInt(ffb); \
219 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
228 * XImage, smooth, depth-buffered, PF_TRUEDITHER triangle.
230 static void smooth_TRUEDITHER_z_triangle( GLcontext
*ctx
,
231 GLuint v0
, GLuint v1
, GLuint v2
,
234 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
235 XMesaImage
*img
= xmesa
->xm_buffer
->backimage
;
238 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
240 #define INNER_LOOP( LEFT, RIGHT, Y ) \
242 GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT; \
243 for (i=0;i<len;i++,xx++) { \
244 GLdepth z = FixedToDepth(ffz); \
247 PACK_TRUEDITHER( p, xx, yy, FixedToInt(ffr), \
248 FixedToInt(ffg), FixedToInt(ffb) ); \
249 XMesaPutPixel( img, xx, yy, p ); \
252 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
261 * XImage, smooth, depth-buffered, PF_5R6G5B triangle.
263 static void smooth_5R6G5B_z_triangle( GLcontext
*ctx
,
264 GLuint v0
, GLuint v1
, GLuint v2
,
267 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
270 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
272 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
273 #define PIXEL_TYPE GLushort
274 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
275 #define INNER_LOOP( LEFT, RIGHT, Y ) \
277 GLint i, len = RIGHT-LEFT; \
278 for (i=0;i<len;i++) { \
279 DEPTH_TYPE z = FixedToDepth(ffz); \
281 pRow[i] = PACK_5R6G5B( FixedToInt(ffr), FixedToInt(ffg), \
285 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
294 * XImage, smooth, depth-buffered, PF_DITHER_5R6G5B triangle.
296 static void smooth_DITHER_5R6G5B_z_triangle( GLcontext
*ctx
,
297 GLuint v0
, GLuint v1
, GLuint v2
,
300 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
303 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
305 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
306 #define PIXEL_TYPE GLushort
307 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
308 #define INNER_LOOP( LEFT, RIGHT, Y ) \
310 GLint i, len = RIGHT-LEFT; \
311 for (i=0;i<len;i++) { \
312 GLdepth z = FixedToDepth(ffz); \
314 PACK_TRUEDITHER(pRow[i], LEFT+i, Y, FixedToInt(ffr), \
315 FixedToInt(ffg), FixedToInt(ffb) ); \
318 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
327 * XImage, smooth, depth-buffered, 8-bit, PF_DITHER8 triangle.
329 static void smooth_DITHER8_z_triangle( GLcontext
*ctx
,
330 GLuint v0
, GLuint v1
, GLuint v2
,
333 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
336 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
338 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
339 #define PIXEL_TYPE GLubyte
340 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
341 #define INNER_LOOP( LEFT, RIGHT, Y ) \
343 GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT; \
345 for (i=0;i<len;i++,xx++) { \
346 GLdepth z = FixedToDepth(ffz); \
348 pRow[i] = (PIXEL_TYPE) XDITHER( xx, FixedToInt(ffr), \
349 FixedToInt(ffg), FixedToInt(ffb) ); \
352 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
361 * XImage, smooth, depth-buffered, PF_DITHER triangle.
363 static void smooth_DITHER_z_triangle( GLcontext
*ctx
,
364 GLuint v0
, GLuint v1
, GLuint v2
,
367 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
368 XMesaImage
*img
= xmesa
->xm_buffer
->backimage
;
371 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
373 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
374 #define PIXEL_TYPE GLubyte
375 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
376 #define INNER_LOOP( LEFT, RIGHT, Y ) \
378 GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT; \
380 for (i=0;i<len;i++,xx++) { \
381 GLdepth z = FixedToDepth(ffz); \
383 unsigned long p = XDITHER( xx, FixedToInt(ffr), \
384 FixedToInt(ffg), FixedToInt(ffb) ); \
385 XMesaPutPixel( img, xx, yy, p ); \
388 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
397 * XImage, smooth, depth-buffered, 8-bit PF_LOOKUP triangle.
399 static void smooth_LOOKUP8_z_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
400 GLuint v2
, GLuint pv
)
402 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
405 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
407 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
408 #define PIXEL_TYPE GLubyte
409 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
410 #define INNER_LOOP( LEFT, RIGHT, Y ) \
412 GLint i, len = RIGHT-LEFT; \
414 for (i=0;i<len;i++) { \
415 GLdepth z = FixedToDepth(ffz); \
417 pRow[i] = LOOKUP( FixedToInt(ffr), FixedToInt(ffg), \
421 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
431 * XImage, smooth, depth-buffered, 8-bit PF_HPCR triangle.
433 static void smooth_HPCR_z_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
434 GLuint v2
, GLuint pv
)
436 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
439 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
441 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
442 #define PIXEL_TYPE GLubyte
443 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
444 #define INNER_LOOP( LEFT, RIGHT, Y ) \
446 GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT; \
447 for (i=0;i<len;i++,xx++) { \
448 GLdepth z = FixedToDepth(ffz); \
450 pRow[i] = DITHER_HPCR( xx, yy, FixedToInt(ffr), \
451 FixedToInt(ffg), FixedToInt(ffb) ); \
454 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
463 * XImage, flat, depth-buffered, PF_TRUECOLOR triangle.
465 static void flat_TRUECOLOR_z_triangle( GLcontext
*ctx
,
466 GLuint v0
, GLuint v1
, GLuint v2
,
469 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
470 XMesaImage
*img
= xmesa
->xm_buffer
->backimage
;
472 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
474 unsigned long pixel; \
475 PACK_TRUECOLOR(pixel, VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2]);
477 #define INNER_LOOP( LEFT, RIGHT, Y ) \
479 GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT; \
480 for (i=0;i<len;i++,xx++) { \
481 GLdepth z = FixedToDepth(ffz); \
483 XMesaPutPixel( img, xx, yy, pixel ); \
494 * XImage, flat, depth-buffered, PF_8A8B8G8R triangle.
496 static void flat_8A8B8G8R_z_triangle( GLcontext
*ctx
, GLuint v0
,
497 GLuint v1
, GLuint v2
, GLuint pv
)
499 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
501 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
502 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
503 #define PIXEL_TYPE GLuint
504 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
506 unsigned long p = PACK_8B8G8R( VB->ColorPtr->data[pv][0], \
507 VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
508 #define INNER_LOOP( LEFT, RIGHT, Y ) \
510 GLint i, len = RIGHT-LEFT; \
511 for (i=0;i<len;i++) { \
512 GLdepth z = FixedToDepth(ffz); \
514 pRow[i] = (PIXEL_TYPE) p; \
525 * XImage, flat, depth-buffered, PF_8R8G8B triangle.
527 static void flat_8R8G8B_z_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
528 GLuint v2
, GLuint pv
)
530 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
532 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
533 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
534 #define PIXEL_TYPE GLuint
535 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
537 unsigned long p = PACK_8R8G8B( VB->ColorPtr->data[pv][0], \
538 VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
539 #define INNER_LOOP( LEFT, RIGHT, Y ) \
541 GLint i, len = RIGHT-LEFT; \
542 for (i=0;i<len;i++) { \
543 GLdepth z = FixedToDepth(ffz); \
545 pRow[i] = (PIXEL_TYPE) p; \
556 * XImage, flat, depth-buffered, PF_8R8G8B24 triangle.
558 static void flat_8R8G8B24_z_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
559 GLuint v2
, GLuint pv
)
561 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
562 const GLubyte
*color
= ctx
->VB
->ColorPtr
->data
[pv
];
564 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
565 #define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
566 #define PIXEL_TYPE bgr_t
567 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
568 #define INNER_LOOP( LEFT, RIGHT, Y ) \
570 GLint i, len = RIGHT-LEFT; \
571 for (i=0;i<len;i++) { \
572 GLdepth z = FixedToDepth(ffz); \
574 PIXEL_TYPE *ptr = pRow+i; \
575 ptr->r = color[RCOMP]; \
576 ptr->g = color[GCOMP]; \
577 ptr->b = color[BCOMP]; \
588 * XImage, flat, depth-buffered, PF_TRUEDITHER triangle.
590 static void flat_TRUEDITHER_z_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
591 GLuint v2
, GLuint pv
)
593 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
594 XMesaImage
*img
= xmesa
->xm_buffer
->backimage
;
596 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
597 #define INNER_LOOP( LEFT, RIGHT, Y ) \
599 GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT; \
600 for (i=0;i<len;i++,xx++) { \
601 GLdepth z = FixedToDepth(ffz); \
604 PACK_TRUEDITHER( p, xx, yy, VB->ColorPtr->data[pv][0], \
605 VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] ); \
606 XMesaPutPixel( img, xx, yy, p ); \
617 * XImage, flat, depth-buffered, PF_5R6G5B triangle.
619 static void flat_5R6G5B_z_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
620 GLuint v2
, GLuint pv
)
622 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
624 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
625 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
626 #define PIXEL_TYPE GLushort
627 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
629 unsigned long p = PACK_5R6G5B( VB->ColorPtr->data[pv][0], \
630 VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
631 #define INNER_LOOP( LEFT, RIGHT, Y ) \
633 GLint i, len = RIGHT-LEFT; \
634 for (i=0;i<len;i++) { \
635 DEPTH_TYPE z = FixedToDepth(ffz); \
637 pRow[i] = (PIXEL_TYPE) p; \
648 * XImage, flat, depth-buffered, PF_DITHER_5R6G5B triangle.
650 static void flat_DITHER_5R6G5B_z_triangle( GLcontext
*ctx
, GLuint v0
,
651 GLuint v1
, GLuint v2
, GLuint pv
)
653 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
654 const GLubyte
*color
= ctx
->VB
->ColorPtr
->data
[pv
];
656 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
657 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
658 #define PIXEL_TYPE GLushort
659 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
660 #define INNER_LOOP( LEFT, RIGHT, Y ) \
662 GLint i, len = RIGHT-LEFT; \
663 for (i=0;i<len;i++) { \
664 DEPTH_TYPE z = FixedToDepth(ffz); \
666 PACK_TRUEDITHER(pRow[i], LEFT+i, Y, color[RCOMP], \
667 color[GCOMP], color[BCOMP]); \
678 * XImage, flat, depth-buffered, 8-bit PF_DITHER triangle.
680 static void flat_DITHER8_z_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
681 GLuint v2
, GLuint pv
)
683 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
685 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
686 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
687 #define PIXEL_TYPE GLubyte
688 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
690 FLAT_DITHER_SETUP( VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
692 #define INNER_LOOP( LEFT, RIGHT, Y ) \
694 GLint i, xx = LEFT, len = RIGHT-LEFT; \
695 FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, Y)); \
696 for (i=0;i<len;i++,xx++) { \
697 GLdepth z = FixedToDepth(ffz); \
699 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(xx); \
710 * XImage, flat, depth-buffered, PF_DITHER triangle.
712 static void flat_DITHER_z_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
713 GLuint v2
, GLuint pv
)
715 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
716 XMesaImage
*img
= xmesa
->xm_buffer
->backimage
;
718 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
720 FLAT_DITHER_SETUP( VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
722 #define INNER_LOOP( LEFT, RIGHT, Y ) \
724 GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT; \
725 FLAT_DITHER_ROW_SETUP(yy); \
726 for (i=0;i<len;i++,xx++) { \
727 GLdepth z = FixedToDepth(ffz); \
729 unsigned long p = FLAT_DITHER(xx); \
730 XMesaPutPixel( img, xx, yy, p ); \
741 * XImage, flat, depth-buffered, 8-bit PF_HPCR triangle.
743 static void flat_HPCR_z_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
744 GLuint v2
, GLuint pv
)
746 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
748 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
749 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
750 #define PIXEL_TYPE GLubyte
751 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
753 GLubyte r = VB->ColorPtr->data[pv][0]; \
754 GLubyte g = VB->ColorPtr->data[pv][1]; \
755 GLubyte b = VB->ColorPtr->data[pv][2];
756 #define INNER_LOOP( LEFT, RIGHT, Y ) \
758 GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT; \
759 for (i=0;i<len;i++,xx++) { \
760 GLdepth z = FixedToDepth(ffz); \
762 pRow[i] = (PIXEL_TYPE) DITHER_HPCR( xx, yy, r, g, b ); \
773 * XImage, flat, depth-buffered, 8-bit PF_LOOKUP triangle.
775 static void flat_LOOKUP8_z_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
776 GLuint v2
, GLuint pv
)
778 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
780 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
781 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
782 #define PIXEL_TYPE GLubyte
783 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
786 GLubyte r = VB->ColorPtr->data[pv][0]; \
787 GLubyte g = VB->ColorPtr->data[pv][1]; \
788 GLubyte b = VB->ColorPtr->data[pv][2]; \
789 GLubyte p = LOOKUP(r,g,b);
790 #define INNER_LOOP( LEFT, RIGHT, Y ) \
792 GLint i, len = RIGHT-LEFT; \
793 for (i=0;i<len;i++) { \
794 GLdepth z = FixedToDepth(ffz); \
808 * XImage, smooth, NON-depth-buffered, PF_TRUECOLOR triangle.
810 static void smooth_TRUECOLOR_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
811 GLuint v2
, GLuint pv
)
813 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
814 XMesaImage
*img
= xmesa
->xm_buffer
->backimage
;
817 #define INNER_LOOP( LEFT, RIGHT, Y ) \
819 GLint xx, yy = FLIP(xmesa->xm_buffer, Y); \
820 for (xx=LEFT;xx<RIGHT;xx++) { \
822 PACK_TRUECOLOR(p, FixedToInt(ffr), FixedToInt(ffg), FixedToInt(ffb));\
823 XMesaPutPixel( img, xx, yy, p ); \
824 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
832 * XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle.
834 static void smooth_8A8B8G8R_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
835 GLuint v2
, GLuint pv
)
837 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
840 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
841 #define PIXEL_TYPE GLuint
842 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
843 #define INNER_LOOP( LEFT, RIGHT, Y ) \
846 PIXEL_TYPE *pixel = pRow; \
847 for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
848 *pixel = PACK_8B8G8R( FixedToInt(ffr), FixedToInt(ffg), \
850 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
858 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
860 static void smooth_8R8G8B_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
861 GLuint v2
, GLuint pv
)
863 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
866 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
867 #define PIXEL_TYPE GLuint
868 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
869 #define INNER_LOOP( LEFT, RIGHT, Y ) \
872 PIXEL_TYPE *pixel = pRow; \
873 for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
874 *pixel = PACK_8R8G8B( FixedToInt(ffr), FixedToInt(ffg), \
876 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
884 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
886 static void smooth_8R8G8B24_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
887 GLuint v2
, GLuint pv
)
889 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
892 #define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
893 #define PIXEL_TYPE bgr_t
894 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
895 #define INNER_LOOP( LEFT, RIGHT, Y ) \
898 PIXEL_TYPE *pixel = pRow; \
899 for (xx=LEFT;xx<RIGHT;xx++) { \
900 pixel->r = FixedToInt(ffr); \
901 pixel->g = FixedToInt(ffg); \
902 pixel->b = FixedToInt(ffb); \
903 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
912 * XImage, smooth, NON-depth-buffered, PF_TRUEDITHER triangle.
914 static void smooth_TRUEDITHER_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
915 GLuint v2
, GLuint pv
)
917 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
918 XMesaImage
*img
= xmesa
->xm_buffer
->backimage
;
921 #define INNER_LOOP( LEFT, RIGHT, Y ) \
923 GLint xx, yy = FLIP(xmesa->xm_buffer, Y); \
924 for (xx=LEFT;xx<RIGHT;xx++) { \
926 PACK_TRUEDITHER( p, xx, yy, FixedToInt(ffr), FixedToInt(ffg), \
928 XMesaPutPixel( img, xx, yy, p ); \
929 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
937 * XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle.
939 static void smooth_5R6G5B_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
940 GLuint v2
, GLuint pv
)
942 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
945 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
946 #define PIXEL_TYPE GLushort
947 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
948 #define INNER_LOOP( LEFT, RIGHT, Y ) \
951 PIXEL_TYPE *pixel = pRow; \
952 for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
953 *pixel = (PIXEL_TYPE) PACK_5R6G5B( FixedToInt(ffr), \
954 FixedToInt(ffg), FixedToInt(ffb) ); \
955 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
963 * XImage, smooth, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
965 static void smooth_DITHER_5R6G5B_triangle( GLcontext
*ctx
, GLuint v0
,
966 GLuint v1
, GLuint v2
, GLuint pv
)
968 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
971 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
972 #define PIXEL_TYPE GLushort
973 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
974 #define INNER_LOOP( LEFT, RIGHT, Y ) \
977 PIXEL_TYPE *pixel = pRow; \
978 for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
979 PACK_TRUEDITHER(*pixel, xx, Y, FixedToInt(ffr), \
980 FixedToInt(ffg), FixedToInt(ffb) ); \
981 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
989 * XImage, smooth, NON-depth-buffered, 8-bit PF_DITHER triangle.
991 static void smooth_DITHER8_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
992 GLuint v2
, GLuint pv
)
994 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
997 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
998 #define PIXEL_TYPE GLubyte
999 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1000 #define INNER_LOOP( LEFT, RIGHT, Y ) \
1002 GLint xx, yy = FLIP(xmesa->xm_buffer, Y); \
1003 PIXEL_TYPE *pixel = pRow; \
1004 XDITHER_SETUP(yy); \
1005 for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
1006 *pixel = (PIXEL_TYPE) XDITHER( xx, FixedToInt(ffr), \
1007 FixedToInt(ffg), FixedToInt(ffb) ); \
1008 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
1011 #include "tritemp.h"
1016 * XImage, smooth, NON-depth-buffered, PF_DITHER triangle.
1018 static void smooth_DITHER_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
1019 GLuint v2
, GLuint pv
)
1021 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
1022 XMesaImage
*img
= xmesa
->xm_buffer
->backimage
;
1024 #define INTERP_RGB 1
1025 #define INNER_LOOP( LEFT, RIGHT, Y ) \
1027 GLint xx, yy = FLIP(xmesa->xm_buffer, Y); \
1028 XDITHER_SETUP(yy); \
1029 for (xx=LEFT;xx<RIGHT;xx++) { \
1030 unsigned long p = XDITHER( xx, FixedToInt(ffr), \
1031 FixedToInt(ffg), FixedToInt(ffb) ); \
1032 XMesaPutPixel( img, xx, yy, p ); \
1033 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
1036 #include "tritemp.h"
1041 * XImage, smooth, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
1043 static void smooth_LOOKUP8_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
1044 GLuint v2
, GLuint pv
)
1046 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
1048 #define INTERP_RGB 1
1049 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
1050 #define PIXEL_TYPE GLubyte
1051 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1052 #define INNER_LOOP( LEFT, RIGHT, Y ) \
1055 PIXEL_TYPE *pixel = pRow; \
1057 for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
1058 *pixel = LOOKUP( FixedToInt(ffr), FixedToInt(ffg), \
1059 FixedToInt(ffb) ); \
1060 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
1063 #include "tritemp.h"
1069 * XImage, smooth, NON-depth-buffered, 8-bit PF_HPCR triangle.
1071 static void smooth_HPCR_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
1072 GLuint v2
, GLuint pv
)
1074 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
1076 #define INTERP_RGB 1
1077 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
1078 #define PIXEL_TYPE GLubyte
1079 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1080 #define INNER_LOOP( LEFT, RIGHT, Y ) \
1082 GLint xx, yy = FLIP(xmesa->xm_buffer, Y); \
1083 PIXEL_TYPE *pixel = pRow; \
1084 for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
1085 *pixel = DITHER_HPCR( xx, yy, FixedToInt(ffr), \
1086 FixedToInt(ffg), FixedToInt(ffb) ); \
1087 ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
1090 #include "tritemp.h"
1095 * XImage, flat, NON-depth-buffered, PF_TRUECOLOR triangle.
1097 static void flat_TRUECOLOR_triangle( GLcontext
*ctx
, GLuint v0
,
1098 GLuint v1
, GLuint v2
, GLuint pv
)
1100 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
1101 XMesaImage
*img
= xmesa
->xm_buffer
->backimage
;
1102 #define SETUP_CODE \
1103 unsigned long pixel; \
1104 PACK_TRUECOLOR(pixel, VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2]);
1106 #define INNER_LOOP( LEFT, RIGHT, Y ) \
1108 GLint xx, yy = FLIP(xmesa->xm_buffer, Y); \
1109 for (xx=LEFT;xx<RIGHT;xx++) { \
1110 XMesaPutPixel( img, xx, yy, pixel ); \
1113 #include "tritemp.h"
1118 * XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle.
1120 static void flat_8A8B8G8R_triangle( GLcontext
*ctx
, GLuint v0
,
1121 GLuint v1
, GLuint v2
, GLuint pv
)
1123 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
1124 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
1125 #define PIXEL_TYPE GLuint
1126 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1127 #define SETUP_CODE \
1128 unsigned long p = PACK_8B8G8R( VB->ColorPtr->data[pv][0], \
1129 VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
1130 #define INNER_LOOP( LEFT, RIGHT, Y ) \
1133 PIXEL_TYPE *pixel = pRow; \
1134 for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
1135 *pixel = (PIXEL_TYPE) p; \
1138 #include "tritemp.h"
1143 * XImage, flat, NON-depth-buffered, PF_8R8G8B triangle.
1145 static void flat_8R8G8B_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
1146 GLuint v2
, GLuint pv
)
1148 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
1149 #define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
1150 #define PIXEL_TYPE GLuint
1151 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1152 #define SETUP_CODE \
1153 unsigned long p = PACK_8R8G8B( VB->ColorPtr->data[pv][0], \
1154 VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
1155 #define INNER_LOOP( LEFT, RIGHT, Y ) \
1158 PIXEL_TYPE *pixel = pRow; \
1159 for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
1160 *pixel = (PIXEL_TYPE) p; \
1163 #include "tritemp.h"
1168 * XImage, flat, NON-depth-buffered, PF_8R8G8B24 triangle.
1170 static void flat_8R8G8B24_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
1171 GLuint v2
, GLuint pv
)
1173 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
1174 const GLubyte
*color
= ctx
->VB
->ColorPtr
->data
[pv
];
1175 #define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
1176 #define PIXEL_TYPE bgr_t
1177 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1178 #define INNER_LOOP( LEFT, RIGHT, Y ) \
1181 PIXEL_TYPE *pixel = pRow; \
1182 for (xx=LEFT;xx<RIGHT;xx++) { \
1183 pixel->r = color[RCOMP]; \
1184 pixel->g = color[GCOMP]; \
1185 pixel->b = color[BCOMP]; \
1189 #include "tritemp.h"
1193 * XImage, flat, NON-depth-buffered, PF_TRUEDITHER triangle.
1195 static void flat_TRUEDITHER_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
1196 GLuint v2
, GLuint pv
)
1198 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
1199 XMesaImage
*img
= xmesa
->xm_buffer
->backimage
;
1200 #define INNER_LOOP( LEFT, RIGHT, Y ) \
1202 GLint xx, yy = FLIP(xmesa->xm_buffer, Y); \
1203 for (xx=LEFT;xx<RIGHT;xx++) { \
1205 PACK_TRUEDITHER( p, xx, yy, VB->ColorPtr->data[pv][0], \
1206 VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] ); \
1207 XMesaPutPixel( img, xx, yy, p ); \
1210 #include "tritemp.h"
1216 * XImage, flat, NON-depth-buffered, PF_5R6G5B triangle.
1218 static void flat_5R6G5B_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
1219 GLuint v2
, GLuint pv
)
1221 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
1222 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
1223 #define PIXEL_TYPE GLushort
1224 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1225 #define SETUP_CODE \
1226 unsigned long p = PACK_5R6G5B( VB->ColorPtr->data[pv][0], \
1227 VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
1228 #define INNER_LOOP( LEFT, RIGHT, Y ) \
1231 PIXEL_TYPE *pixel = pRow; \
1232 for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
1233 *pixel = (PIXEL_TYPE) p; \
1236 #include "tritemp.h"
1241 * XImage, flat, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
1243 static void flat_DITHER_5R6G5B_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
1244 GLuint v2
, GLuint pv
)
1246 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
1247 const GLubyte
*color
= ctx
->VB
->ColorPtr
->data
[pv
];
1248 #define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
1249 #define PIXEL_TYPE GLushort
1250 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1251 #define INNER_LOOP( LEFT, RIGHT, Y ) \
1254 PIXEL_TYPE *pixel = pRow; \
1255 for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
1256 PACK_TRUEDITHER(*pixel, xx, Y, color[RCOMP], \
1257 color[GCOMP], color[BCOMP]); \
1260 #include "tritemp.h"
1265 * XImage, flat, NON-depth-buffered, 8-bit PF_DITHER triangle.
1267 static void flat_DITHER8_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
1268 GLuint v2
, GLuint pv
)
1270 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
1271 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
1272 #define PIXEL_TYPE GLubyte
1273 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1274 #define SETUP_CODE \
1275 FLAT_DITHER_SETUP( VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
1277 #define INNER_LOOP( LEFT, RIGHT, Y ) \
1280 PIXEL_TYPE *pixel = pRow; \
1281 FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, Y)); \
1282 for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
1283 *pixel = (PIXEL_TYPE) FLAT_DITHER(xx); \
1286 #include "tritemp.h"
1291 * XImage, flat, NON-depth-buffered, PF_DITHER triangle.
1293 static void flat_DITHER_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
1294 GLuint v2
, GLuint pv
)
1296 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
1297 XMesaImage
*img
= xmesa
->xm_buffer
->backimage
;
1298 #define SETUP_CODE \
1299 FLAT_DITHER_SETUP( VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
1301 #define INNER_LOOP( LEFT, RIGHT, Y ) \
1303 GLint xx, yy = FLIP(xmesa->xm_buffer, Y); \
1304 FLAT_DITHER_ROW_SETUP(yy); \
1305 for (xx=LEFT;xx<RIGHT;xx++) { \
1306 unsigned long p = FLAT_DITHER(xx); \
1307 XMesaPutPixel( img, xx, yy, p ); \
1310 #include "tritemp.h"
1315 * XImage, flat, NON-depth-buffered, 8-bit PF_HPCR triangle.
1317 static void flat_HPCR_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
1318 GLuint v2
, GLuint pv
)
1320 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
1321 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
1322 #define PIXEL_TYPE GLubyte
1323 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1324 #define SETUP_CODE \
1325 GLubyte r = VB->ColorPtr->data[pv][0]; \
1326 GLubyte g = VB->ColorPtr->data[pv][1]; \
1327 GLubyte b = VB->ColorPtr->data[pv][2];
1328 #define INNER_LOOP( LEFT, RIGHT, Y ) \
1330 GLint xx, yy = FLIP(xmesa->xm_buffer, Y); \
1331 PIXEL_TYPE *pixel = pRow; \
1332 for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
1333 *pixel = (PIXEL_TYPE) DITHER_HPCR( xx, yy, r, g, b ); \
1336 #include "tritemp.h"
1341 * XImage, flat, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
1343 static void flat_LOOKUP8_triangle( GLcontext
*ctx
, GLuint v0
, GLuint v1
,
1344 GLuint v2
, GLuint pv
)
1346 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
1347 #define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
1348 #define PIXEL_TYPE GLubyte
1349 #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
1350 #define SETUP_CODE \
1352 GLubyte r = VB->ColorPtr->data[pv][0]; \
1353 GLubyte g = VB->ColorPtr->data[pv][1]; \
1354 GLubyte b = VB->ColorPtr->data[pv][2]; \
1355 GLubyte p = LOOKUP(r,g,b);
1356 #define INNER_LOOP( LEFT, RIGHT, Y ) \
1359 PIXEL_TYPE *pixel = pRow; \
1360 for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
1364 #include "tritemp.h"
1371 * This function is called if we're about to render triangles into an
1372 * X window/pixmap. It sets the polygon stipple pattern if enabled.
1374 static void setup_x_polygon_options( GLcontext
*ctx
)
1376 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
1379 if (ctx
->Polygon
.StippleFlag
) {
1380 if (xmesa
->xm_buffer
->stipple_pixmap
== 0) {
1381 /* Allocate polygon stippling stuff once for this context. */
1382 XMesaBuffer b
= xmesa
->xm_buffer
;
1383 b
->stipple_pixmap
= XMesaCreatePixmap( xmesa
->display
,
1384 b
->buffer
, 32, 32, 1 );
1385 #ifdef XFree86Server
1386 b
->stipple_gc
= CreateScratchGC(xmesa
->display
, 1);
1388 b
->stipple_gc
= XCreateGC(xmesa
->display
, b
->stipple_pixmap
, 0, NULL
);
1390 XMesaSetFunction(xmesa
->display
, b
->stipple_gc
, GXcopy
);
1391 XMesaSetForeground(xmesa
->display
, b
->stipple_gc
, 1);
1392 XMesaSetBackground(xmesa
->display
, b
->stipple_gc
, 0);
1396 * NOTE: We don't handle the following here!
1397 * GL_UNPACK_SWAP_BYTES
1398 * GL_UNPACK_LSB_FIRST
1400 /* Copy Mesa stipple pattern to an XImage then to Pixmap */
1402 XMesaImage
*stipple_ximage
;
1405 int shift
= xmesa
->xm_buffer
->height
% 32;
1406 for (i
=0;i
<32;i
++) {
1407 stipple
[31-i
] = ctx
->PolygonStipple
[(i
+shift
) % 32];
1409 #ifdef XFree86Server
1410 stipple_ximage
= XMesaCreateImage(1, 32, 32, (char *)stipple
);
1412 stipple_ximage
= XCreateImage( xmesa
->display
,
1413 xmesa
->xm_visual
->visinfo
->visual
,
1417 stipple_ximage
->byte_order
= LSBFirst
;
1418 stipple_ximage
->bitmap_bit_order
= LSBFirst
;
1419 stipple_ximage
->bitmap_unit
= 32;
1421 XMesaPutImage( xmesa
->display
,
1422 (XMesaDrawable
)xmesa
->xm_buffer
->stipple_pixmap
,
1423 xmesa
->xm_buffer
->stipple_gc
,
1424 stipple_ximage
, 0, 0, 0, 0, 32, 32 );
1425 stipple_ximage
->data
= NULL
;
1426 XMesaDestroyImage( stipple_ximage
);
1429 XMesaSetStipple( xmesa
->display
, xmesa
->xm_buffer
->gc1
,
1430 xmesa
->xm_buffer
->stipple_pixmap
);
1431 XMesaSetStipple( xmesa
->display
, xmesa
->xm_buffer
->gc2
,
1432 xmesa
->xm_buffer
->stipple_pixmap
);
1433 fill_type
= FillStippled
;
1436 fill_type
= FillSolid
;
1439 XMesaSetFillStyle( xmesa
->display
, xmesa
->xm_buffer
->gc1
, fill_type
);
1440 XMesaSetFillStyle( xmesa
->display
, xmesa
->xm_buffer
->gc2
, fill_type
);
1447 _xmesa_print_triangle_func( triangle_func triFunc
)
1449 printf("XMesa tri func = ");
1450 if (triFunc
==smooth_TRUECOLOR_z_triangle
)
1451 printf("smooth_TRUECOLOR_z_triangle\n");
1452 else if (triFunc
==smooth_8A8B8G8R_z_triangle
)
1453 printf("smooth_8A8B8G8R_z_triangle\n");
1454 else if (triFunc
==smooth_8R8G8B_z_triangle
)
1455 printf("smooth_8R8G8B_z_triangle\n");
1456 else if (triFunc
==smooth_8R8G8B24_z_triangle
)
1457 printf("smooth_8R8G8B24_z_triangle\n");
1458 else if (triFunc
==smooth_TRUEDITHER_z_triangle
)
1459 printf("smooth_TRUEDITHER_z_triangle\n");
1460 else if (triFunc
==smooth_5R6G5B_z_triangle
)
1461 printf("smooth_5R6G5B_z_triangle\n");
1462 else if (triFunc
==smooth_DITHER_5R6G5B_z_triangle
)
1463 printf("smooth_DITHER_5R6G5B_z_triangle\n");
1464 else if (triFunc
==smooth_HPCR_z_triangle
)
1465 printf("smooth_HPCR_z_triangle\n");
1466 else if (triFunc
==smooth_DITHER8_z_triangle
)
1467 printf("smooth_DITHER8_z_triangle\n");
1468 else if (triFunc
==smooth_LOOKUP8_z_triangle
)
1469 printf("smooth_LOOKUP8_z_triangle\n");
1470 else if (triFunc
==flat_TRUECOLOR_z_triangle
)
1471 printf("flat_TRUECOLOR_z_triangle\n");
1472 else if (triFunc
==flat_8A8B8G8R_z_triangle
)
1473 printf("flat_8A8B8G8R_z_triangle\n");
1474 else if (triFunc
==flat_8R8G8B_z_triangle
)
1475 printf("flat_8R8G8B_z_triangle\n");
1476 else if (triFunc
==flat_8R8G8B24_z_triangle
)
1477 printf("flat_8R8G8B24_z_triangle\n");
1478 else if (triFunc
==flat_TRUEDITHER_z_triangle
)
1479 printf("flat_TRUEDITHER_z_triangle\n");
1480 else if (triFunc
==flat_5R6G5B_z_triangle
)
1481 printf("flat_5R6G5B_z_triangle\n");
1482 else if (triFunc
==flat_DITHER_5R6G5B_z_triangle
)
1483 printf("flat_DITHER_5R6G5B_z_triangle\n");
1484 else if (triFunc
==flat_HPCR_z_triangle
)
1485 printf("flat_HPCR_z_triangle\n");
1486 else if (triFunc
==flat_DITHER8_z_triangle
)
1487 printf("flat_DITHER8_z_triangle\n");
1488 else if (triFunc
==flat_LOOKUP8_z_triangle
)
1489 printf("flat_LOOKUP8_z_triangle\n");
1490 else if (triFunc
==smooth_TRUECOLOR_triangle
)
1491 printf("smooth_TRUECOLOR_triangle\n");
1492 else if (triFunc
==smooth_8A8B8G8R_triangle
)
1493 printf("smooth_8A8B8G8R_triangle\n");
1494 else if (triFunc
==smooth_8R8G8B_triangle
)
1495 printf("smooth_8R8G8B_triangle\n");
1496 else if (triFunc
==smooth_8R8G8B24_triangle
)
1497 printf("smooth_8R8G8B24_triangle\n");
1498 else if (triFunc
==smooth_TRUEDITHER_triangle
)
1499 printf("smooth_TRUEDITHER_triangle\n");
1500 else if (triFunc
==smooth_5R6G5B_triangle
)
1501 printf("smooth_5R6G5B_triangle\n");
1502 else if (triFunc
==smooth_DITHER_5R6G5B_triangle
)
1503 printf("smooth_DITHER_5R6G5B_triangle\n");
1504 else if (triFunc
==smooth_HPCR_triangle
)
1505 printf("smooth_HPCR_triangle\n");
1506 else if (triFunc
==smooth_DITHER8_triangle
)
1507 printf("smooth_DITHER8_triangle\n");
1508 else if (triFunc
==smooth_LOOKUP8_triangle
)
1509 printf("smooth_LOOKUP8_triangle\n");
1510 else if (triFunc
==flat_TRUECOLOR_triangle
)
1511 printf("flat_TRUECOLOR_triangle\n");
1512 else if (triFunc
==flat_TRUEDITHER_triangle
)
1513 printf("flat_TRUEDITHER_triangle\n");
1514 else if (triFunc
==flat_8A8B8G8R_triangle
)
1515 printf("flat_8A8B8G8R_triangle\n");
1516 else if (triFunc
==flat_8R8G8B_triangle
)
1517 printf("flat_8R8G8B_triangle\n");
1518 else if (triFunc
==flat_8R8G8B24_triangle
)
1519 printf("flat_8R8G8B24_triangle\n");
1520 else if (triFunc
==flat_5R6G5B_triangle
)
1521 printf("flat_5R6G5B_triangle\n");
1522 else if (triFunc
==flat_DITHER_5R6G5B_triangle
)
1523 printf("flat_DITHER_5R6G5B_triangle\n");
1524 else if (triFunc
==flat_HPCR_triangle
)
1525 printf("flat_HPCR_triangle\n");
1526 else if (triFunc
==flat_DITHER8_triangle
)
1527 printf("flat_DITHER8_triangle\n");
1528 else if (triFunc
==flat_LOOKUP8_triangle
)
1529 printf("flat_LOOKUP8_triangle\n");
1536 triangle_func
xmesa_get_triangle_func( GLcontext
*ctx
)
1538 XMesaContext xmesa
= (XMesaContext
) ctx
->DriverCtx
;
1539 int depth
= GET_VISUAL_DEPTH(xmesa
->xm_visual
);
1543 if (ctx
->Polygon
.SmoothFlag
) return NULL
;
1544 if (ctx
->Texture
.Enabled
) return NULL
;
1546 if (xmesa
->xm_buffer
->buffer
==XIMAGE
) {
1547 if ( ctx
->Light
.ShadeModel
==GL_SMOOTH
1548 && ctx
->RasterMask
==DEPTH_BIT
1549 && ctx
->Depth
.Func
==GL_LESS
1550 && ctx
->Depth
.Mask
==GL_TRUE
1551 && ctx
->Visual
->DepthBits
== DEFAULT_SOFTWARE_DEPTH_BITS
1552 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1553 switch (xmesa
->pixelformat
) {
1555 return smooth_TRUECOLOR_z_triangle
;
1557 return smooth_8A8B8G8R_z_triangle
;
1559 return smooth_8R8G8B_z_triangle
;
1561 return smooth_8R8G8B24_z_triangle
;
1563 return smooth_TRUEDITHER_z_triangle
;
1565 return smooth_5R6G5B_z_triangle
;
1566 case PF_DITHER_5R6G5B
:
1567 return smooth_DITHER_5R6G5B_z_triangle
;
1569 return smooth_HPCR_z_triangle
;
1571 return (depth
==8) ? smooth_DITHER8_z_triangle
1572 : smooth_DITHER_z_triangle
;
1574 return (depth
==8) ? smooth_LOOKUP8_z_triangle
: NULL
;
1579 if ( ctx
->Light
.ShadeModel
==GL_FLAT
1580 && ctx
->RasterMask
==DEPTH_BIT
1581 && ctx
->Depth
.Func
==GL_LESS
1582 && ctx
->Depth
.Mask
==GL_TRUE
1583 && ctx
->Visual
->DepthBits
== DEFAULT_SOFTWARE_DEPTH_BITS
1584 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1585 switch (xmesa
->pixelformat
) {
1587 return flat_TRUECOLOR_z_triangle
;
1589 return flat_8A8B8G8R_z_triangle
;
1591 return flat_8R8G8B_z_triangle
;
1593 return flat_8R8G8B24_z_triangle
;
1595 return flat_TRUEDITHER_z_triangle
;
1597 return flat_5R6G5B_z_triangle
;
1598 case PF_DITHER_5R6G5B
:
1599 return flat_DITHER_5R6G5B_z_triangle
;
1601 return flat_HPCR_z_triangle
;
1603 return (depth
==8) ? flat_DITHER8_z_triangle
1604 : flat_DITHER_z_triangle
;
1606 return (depth
==8) ? flat_LOOKUP8_z_triangle
: NULL
;
1611 if ( ctx
->RasterMask
==0 /* no depth test */
1612 && ctx
->Light
.ShadeModel
==GL_SMOOTH
1613 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1614 switch (xmesa
->pixelformat
) {
1616 return smooth_TRUECOLOR_triangle
;
1618 return smooth_8A8B8G8R_triangle
;
1620 return smooth_8R8G8B_triangle
;
1622 return smooth_8R8G8B24_triangle
;
1624 return smooth_TRUEDITHER_triangle
;
1626 return smooth_5R6G5B_triangle
;
1627 case PF_DITHER_5R6G5B
:
1628 return smooth_DITHER_5R6G5B_triangle
;
1630 return smooth_HPCR_triangle
;
1632 return (depth
==8) ? smooth_DITHER8_triangle
1633 : smooth_DITHER_triangle
;
1635 return (depth
==8) ? smooth_LOOKUP8_triangle
: NULL
;
1641 if ( ctx
->RasterMask
==0 /* no depth test */
1642 && ctx
->Light
.ShadeModel
==GL_FLAT
1643 && ctx
->Polygon
.StippleFlag
==GL_FALSE
) {
1644 switch (xmesa
->pixelformat
) {
1646 return flat_TRUECOLOR_triangle
;
1648 return flat_TRUEDITHER_triangle
;
1650 return flat_8A8B8G8R_triangle
;
1652 return flat_8R8G8B_triangle
;
1654 return flat_8R8G8B24_triangle
;
1656 return flat_5R6G5B_triangle
;
1657 case PF_DITHER_5R6G5B
:
1658 return flat_DITHER_5R6G5B_triangle
;
1660 return flat_HPCR_triangle
;
1662 return (depth
==8) ? flat_DITHER8_triangle
1663 : flat_DITHER_triangle
;
1665 return (depth
==8) ? flat_LOOKUP8_triangle
: NULL
;
1674 /* draw to pixmap */
1676 /* XXX have to disable this because X's rasterization rules
1677 * don't match software Mesa's. This causes a buffer invariance
1678 * test failure in the conformance tests.
1679 * In the future, we might provide a config option to enable this.
1681 if (ctx
->Light
.ShadeModel
==GL_FLAT
&& ctx
->RasterMask
==0) {
1682 if (ctx
->Color
.DitherFlag
&& depth
< 24)
1684 setup_x_polygon_options( ctx
);
1685 return flat_pixmap_triangle
;