projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge branch 'master' into gallium-0.2
[mesa.git] / src / mesa / drivers / x11 / xm_tri.c
1 /*
2 * Mesa 3-D graphics library
3 * Version: 6.5
4 *
5 * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25
26 /*
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.
30 */
31
32
33 #include "main/depth.h"
34 #include "main/macros.h"
35 #include "main/imports.h"
36 #include "main/mtypes.h"
37 #include "glxheader.h"
38 #include "xmesaP.h"
39
40 /* Internal swrast includes:
41 */
42 #include "swrast/s_context.h"
43 #include "swrast/s_depth.h"
44 #include "swrast/s_triangle.h"
45
46
47 #define GET_XRB(XRB) struct xmesa_renderbuffer *XRB = \
48 xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0]->Wrapped)
49
50
51 /**********************************************************************/
52 /*** Triangle rendering ***/
53 /**********************************************************************/
54
55
56 #if CHAN_BITS == 8
57
58 /*
59 * XImage, smooth, depth-buffered, PF_TRUECOLOR triangle.
60 */
61 #define NAME smooth_TRUECOLOR_z_triangle
62 #define INTERP_Z 1
63 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
64 #define INTERP_RGB 1
65 #define SETUP_CODE \
66 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
67 GET_XRB(xrb);
68
69 #define RENDER_SPAN( span ) { \
70 GLint x = span.x, y = YFLIP(xrb, span.y); \
71 GLuint i; \
72 for (i = 0; i < span.end; i++, x++) { \
73 const DEPTH_TYPE z = FixedToDepth(span.z); \
74 if (z < zRow[i]) { \
75 unsigned long p; \
76 PACK_TRUECOLOR(p, FixedToInt(span.red), \
77 FixedToInt(span.green), FixedToInt(span.blue)); \
78 XMesaPutPixel(xrb->ximage, x, y, p); \
79 zRow[i] = z; \
80 } \
81 span.red += span.redStep; \
82 span.green += span.greenStep; \
83 span.blue += span.blueStep; \
84 span.z += span.zStep; \
85 } }
86
87 #include "swrast/s_tritemp.h"
88
89
90
91
92 /*
93 * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle.
94 */
95 #define NAME smooth_8A8B8G8R_z_triangle
96 #define INTERP_Z 1
97 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
98 #define INTERP_RGB 1
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)
103 #define SETUP_CODE \
104 GET_XRB(xrb);
105 #define RENDER_SPAN( span ) { \
106 GLuint i; \
107 for (i = 0; i < span.end; i++) { \
108 const DEPTH_TYPE z = FixedToDepth(span.z); \
109 if (z < zRow[i]) { \
110 pRow[i] = PACK_8A8B8G8R(FixedToInt(span.red), \
111 FixedToInt(span.green), FixedToInt(span.blue), \
112 FixedToInt(span.alpha)); \
113 zRow[i] = z; \
114 } \
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; \
120 } }
121
122 #include "swrast/s_tritemp.h"
123
124
125
126 /*
127 * XImage, smooth, depth-buffered, PF_8A8R8G8B triangle.
128 */
129 #define NAME smooth_8A8R8G8B_z_triangle
130 #define INTERP_Z 1
131 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
132 #define INTERP_RGB 1
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)
137 #define SETUP_CODE \
138 GET_XRB(xrb);
139
140 #define RENDER_SPAN( span ) { \
141 GLuint i; \
142 for (i = 0; i < span.end; i++) { \
143 const DEPTH_TYPE z = FixedToDepth(span.z); \
144 if (z < zRow[i]) { \
145 pRow[i] = PACK_8A8R8G8B(FixedToInt(span.red), \
146 FixedToInt(span.green), FixedToInt(span.blue), \
147 FixedToInt(span.alpha)); \
148 zRow[i] = z; \
149 } \
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; \
155 } }
156
157 #include "swrast/s_tritemp.h"
158
159
160
161 /*
162 * XImage, smooth, depth-buffered, PF_8R8G8B triangle.
163 */
164 #define NAME smooth_8R8G8B_z_triangle
165 #define INTERP_Z 1
166 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
167 #define INTERP_RGB 1
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)
171 #define SETUP_CODE \
172 GET_XRB(xrb);
173
174 #define RENDER_SPAN( span ) { \
175 GLuint i; \
176 for (i = 0; i < span.end; i++) { \
177 const DEPTH_TYPE z = FixedToDepth(span.z); \
178 if (z < zRow[i]) { \
179 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
180 FixedToInt(span.green), FixedToInt(span.blue)); \
181 zRow[i] = z; \
182 } \
183 span.red += span.redStep; \
184 span.green += span.greenStep; \
185 span.blue += span.blueStep; \
186 span.z += span.zStep; \
187 } }
188
189 #include "swrast/s_tritemp.h"
190
191
192
193 /*
194 * XImage, smooth, depth-buffered, PF_8R8G8B24 triangle.
195 */
196 #define NAME smooth_8R8G8B24_z_triangle
197 #define INTERP_Z 1
198 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
199 #define INTERP_RGB 1
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)
203 #define SETUP_CODE \
204 GET_XRB(xrb);
205 #define RENDER_SPAN( span ) { \
206 GLuint i; \
207 for (i = 0; i < span.end; i++) { \
208 const DEPTH_TYPE z = FixedToDepth(span.z); \
209 if (z < zRow[i]) { \
210 PIXEL_TYPE *ptr = pRow + i; \
211 ptr->r = FixedToInt(span.red); \
212 ptr->g = FixedToInt(span.green); \
213 ptr->b = FixedToInt(span.blue); \
214 zRow[i] = z; \
215 } \
216 span.red += span.redStep; \
217 span.green += span.greenStep; \
218 span.blue += span.blueStep; \
219 span.z += span.zStep; \
220 } }
221 #include "swrast/s_tritemp.h"
222
223
224
225 /*
226 * XImage, smooth, depth-buffered, PF_TRUEDITHER triangle.
227 */
228 #define NAME smooth_TRUEDITHER_z_triangle
229 #define INTERP_Z 1
230 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
231 #define INTERP_RGB 1
232 #define SETUP_CODE \
233 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
234 GET_XRB(xrb);
235 #define RENDER_SPAN( span ) { \
236 GLuint i; \
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); \
240 if (z < zRow[i]) { \
241 unsigned long p; \
242 PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \
243 FixedToInt(span.green), FixedToInt(span.blue)); \
244 XMesaPutPixel(xrb->ximage, x, y, p); \
245 zRow[i] = z; \
246 } \
247 span.red += span.redStep; \
248 span.green += span.greenStep; \
249 span.blue += span.blueStep; \
250 span.z += span.zStep; \
251 } }
252 #include "swrast/s_tritemp.h"
253
254
255
256 /*
257 * XImage, smooth, depth-buffered, PF_5R6G5B triangle.
258 */
259 #define NAME smooth_5R6G5B_z_triangle
260 #define INTERP_Z 1
261 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
262 #define INTERP_RGB 1
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)
266 #define SETUP_CODE \
267 GET_XRB(xrb);
268 #define RENDER_SPAN( span ) { \
269 GLuint i; \
270 for (i = 0; i < span.end; i++) { \
271 const DEPTH_TYPE z = FixedToDepth(span.z); \
272 if (z < zRow[i]) { \
273 pRow[i] = PACK_5R6G5B(FixedToInt(span.red), \
274 FixedToInt(span.green), FixedToInt(span.blue)); \
275 zRow[i] = z; \
276 } \
277 span.red += span.redStep; \
278 span.green += span.greenStep; \
279 span.blue += span.blueStep; \
280 span.z += span.zStep; \
281 } }
282 #include "swrast/s_tritemp.h"
283
284
285
286 /*
287 * XImage, smooth, depth-buffered, PF_DITHER_5R6G5B triangle.
288 */
289 #define NAME smooth_DITHER_5R6G5B_z_triangle
290 #define INTERP_Z 1
291 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
292 #define INTERP_RGB 1
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)
296 #define SETUP_CODE \
297 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
298 GET_XRB(xrb);
299 #define RENDER_SPAN( span ) { \
300 GLuint i; \
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); \
304 if (z < zRow[i]) { \
305 PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \
306 FixedToInt(span.green), FixedToInt(span.blue)); \
307 zRow[i] = z; \
308 } \
309 span.red += span.redStep; \
310 span.green += span.greenStep; \
311 span.blue += span.blueStep; \
312 span.z += span.zStep; \
313 } }
314 #include "swrast/s_tritemp.h"
315
316
317
318 /*
319 * XImage, smooth, depth-buffered, 8-bit, PF_DITHER8 triangle.
320 */
321 #define NAME smooth_DITHER8_z_triangle
322 #define INTERP_Z 1
323 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
324 #define INTERP_RGB 1
325 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
326 #define PIXEL_TYPE GLubyte
327 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
328 #define SETUP_CODE \
329 GET_XRB(xrb);
330 #define RENDER_SPAN( span ) { \
331 GLuint i; \
332 GLint x = span.x, y = YFLIP(xrb, span.y); \
333 XDITHER_SETUP(y); \
334 for (i = 0; i < span.end; i++, x++) { \
335 const DEPTH_TYPE z = FixedToDepth(span.z); \
336 if (z < zRow[i]) { \
337 pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red),\
338 FixedToInt(span.green), FixedToInt(span.blue) ); \
339 zRow[i] = z; \
340 } \
341 span.red += span.redStep; \
342 span.green += span.greenStep; \
343 span.blue += span.blueStep; \
344 span.z += span.zStep; \
345 } }
346 #include "swrast/s_tritemp.h"
347
348
349
350 /*
351 * XImage, smooth, depth-buffered, PF_DITHER triangle.
352 */
353 #define NAME smooth_DITHER_z_triangle
354 #define INTERP_Z 1
355 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
356 #define INTERP_RGB 1
357 #define SETUP_CODE \
358 GET_XRB(xrb); \
359 XMesaImage *img = xrb->ximage;
360 #define RENDER_SPAN( span ) { \
361 GLuint i; \
362 GLint x = span.x, y = YFLIP(xrb, span.y); \
363 XDITHER_SETUP(y); \
364 for (i = 0; i < span.end; i++, x++) { \
365 const DEPTH_TYPE z = FixedToDepth(span.z); \
366 if (z < zRow[i]) { \
367 unsigned long p = XDITHER(x, FixedToInt(span.red), \
368 FixedToInt(span.green), FixedToInt(span.blue)); \
369 XMesaPutPixel(img, x, y, p); \
370 zRow[i] = z; \
371 } \
372 span.red += span.redStep; \
373 span.green += span.greenStep; \
374 span.blue += span.blueStep; \
375 span.z += span.zStep; \
376 } }
377 #include "swrast/s_tritemp.h"
378
379
380
381 /*
382 * XImage, smooth, depth-buffered, 8-bit PF_LOOKUP triangle.
383 */
384 #define NAME smooth_LOOKUP8_z_triangle
385 #define INTERP_Z 1
386 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
387 #define INTERP_RGB 1
388 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
389 #define PIXEL_TYPE GLubyte
390 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
391 #define SETUP_CODE \
392 GET_XRB(xrb);
393 #define RENDER_SPAN( span ) { \
394 GLuint i; \
395 LOOKUP_SETUP; \
396 for (i = 0; i < span.end; i++) { \
397 const DEPTH_TYPE z = FixedToDepth(span.z); \
398 if (z < zRow[i]) { \
399 pRow[i] = LOOKUP(FixedToInt(span.red), \
400 FixedToInt(span.green), FixedToInt(span.blue)); \
401 zRow[i] = z; \
402 } \
403 span.red += span.redStep; \
404 span.green += span.greenStep; \
405 span.blue += span.blueStep; \
406 span.z += span.zStep; \
407 } }
408 #include "swrast/s_tritemp.h"
409
410
411
412 /*
413 * XImage, smooth, depth-buffered, 8-bit PF_HPCR triangle.
414 */
415 #define NAME smooth_HPCR_z_triangle
416 #define INTERP_Z 1
417 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
418 #define INTERP_RGB 1
419 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
420 #define PIXEL_TYPE GLubyte
421 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
422 #define SETUP_CODE \
423 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
424 GET_XRB(xrb);
425 #define RENDER_SPAN( span ) { \
426 GLuint i; \
427 GLint x = span.x, y = YFLIP(xrb, span.y); \
428 for (i = 0; i < span.end; i++, x++) { \
429 const DEPTH_TYPE z = FixedToDepth(span.z); \
430 if (z < zRow[i]) { \
431 pRow[i] = DITHER_HPCR(x, y, FixedToInt(span.red), \
432 FixedToInt(span.green), FixedToInt(span.blue) ); \
433 zRow[i] = z; \
434 } \
435 span.red += span.redStep; \
436 span.green += span.greenStep; \
437 span.blue += span.blueStep; \
438 span.z += span.zStep; \
439 } }
440 #include "swrast/s_tritemp.h"
441
442
443
444 /*
445 * XImage, flat, depth-buffered, PF_TRUECOLOR triangle.
446 */
447 #define NAME flat_TRUECOLOR_z_triangle
448 #define INTERP_Z 1
449 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
450 #define SETUP_CODE \
451 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
452 GET_XRB(xrb); \
453 XMesaImage *img = xrb->ximage; \
454 unsigned long pixel; \
455 PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]);
456 #define RENDER_SPAN( span ) { \
457 GLuint i; \
458 GLint x = span.x, y = YFLIP(xrb, span.y); \
459 for (i = 0; i < span.end; i++, x++) { \
460 const DEPTH_TYPE z = FixedToDepth(span.z); \
461 if (z < zRow[i]) { \
462 XMesaPutPixel(img, x, y, pixel); \
463 zRow[i] = z; \
464 } \
465 span.z += span.zStep; \
466 } }
467 #include "swrast/s_tritemp.h"
468
469
470
471 /*
472 * XImage, flat, depth-buffered, PF_8A8B8G8R triangle.
473 */
474 #define NAME flat_8A8B8G8R_z_triangle
475 #define INTERP_Z 1
476 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
477 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
478 #define PIXEL_TYPE GLuint
479 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
480 #define SETUP_CODE \
481 GET_XRB(xrb); \
482 GLuint p = PACK_8A8B8G8R( v2->color[0], v2->color[1],\
483 v2->color[2], v2->color[3]);
484 #define RENDER_SPAN( span ) { \
485 GLuint i; \
486 for (i = 0; i < span.end; i++) { \
487 const DEPTH_TYPE z = FixedToDepth(span.z); \
488 if (z < zRow[i]) { \
489 pRow[i] = (PIXEL_TYPE) p; \
490 zRow[i] = z; \
491 } \
492 span.z += span.zStep; \
493 } }
494 #include "swrast/s_tritemp.h"
495
496
497
498 /*
499 * XImage, flat, depth-buffered, PF_8A8R8G8B triangle.
500 */
501 #define NAME flat_8A8R8G8B_z_triangle
502 #define INTERP_Z 1
503 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
504 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
505 #define PIXEL_TYPE GLuint
506 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
507 #define SETUP_CODE \
508 GET_XRB(xrb); \
509 GLuint p = PACK_8A8R8G8B(v2->color[0], v2->color[1], \
510 v2->color[2], v2->color[3]);
511 #define RENDER_SPAN( span ) { \
512 GLuint i; \
513 for (i = 0; i < span.end; i++) { \
514 const DEPTH_TYPE z = FixedToDepth(span.z); \
515 if (z < zRow[i]) { \
516 pRow[i] = (PIXEL_TYPE) p; \
517 zRow[i] = z; \
518 } \
519 span.z += span.zStep; \
520 } }
521 #include "swrast/s_tritemp.h"
522
523
524
525 /*
526 * XImage, flat, depth-buffered, PF_8R8G8B triangle.
527 */
528 #define NAME flat_8R8G8B_z_triangle
529 #define INTERP_Z 1
530 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
531 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
532 #define PIXEL_TYPE GLuint
533 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
534 #define SETUP_CODE \
535 GET_XRB(xrb); \
536 GLuint p = PACK_8R8G8B( v2->color[0], v2->color[1], v2->color[2] );
537 #define RENDER_SPAN( span ) { \
538 GLuint i; \
539 for (i = 0; i < span.end; i++) { \
540 DEPTH_TYPE z = FixedToDepth(span.z); \
541 if (z < zRow[i]) { \
542 pRow[i] = (PIXEL_TYPE) p; \
543 zRow[i] = z; \
544 } \
545 span.z += span.zStep; \
546 } }
547
548 #include "swrast/s_tritemp.h"
549
550
551
552 /*
553 * XImage, flat, depth-buffered, PF_8R8G8B24 triangle.
554 */
555 #define NAME flat_8R8G8B24_z_triangle
556 #define INTERP_Z 1
557 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
558 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
559 #define PIXEL_TYPE bgr_t
560 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
561 #define SETUP_CODE \
562 GET_XRB(xrb); \
563 const GLubyte *color = v2->color;
564 #define RENDER_SPAN( span ) { \
565 GLuint i; \
566 for (i = 0; i < span.end; i++) { \
567 const DEPTH_TYPE z = FixedToDepth(span.z); \
568 if (z < zRow[i]) { \
569 PIXEL_TYPE *ptr = pRow + i; \
570 ptr->r = color[RCOMP]; \
571 ptr->g = color[GCOMP]; \
572 ptr->b = color[BCOMP]; \
573 zRow[i] = z; \
574 } \
575 span.z += span.zStep; \
576 } }
577 #include "swrast/s_tritemp.h"
578
579
580
581 /*
582 * XImage, flat, depth-buffered, PF_TRUEDITHER triangle.
583 */
584 #define NAME flat_TRUEDITHER_z_triangle
585 #define INTERP_Z 1
586 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
587 #define SETUP_CODE \
588 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
589 GET_XRB(xrb); \
590 XMesaImage *img = xrb->ximage;
591 #define RENDER_SPAN( span ) { \
592 GLuint i; \
593 GLint x = span.x, y = YFLIP(xrb, span.y); \
594 for (i = 0; i < span.end; i++, x++) { \
595 const DEPTH_TYPE z = FixedToDepth(span.z); \
596 if (z < zRow[i]) { \
597 unsigned long p; \
598 PACK_TRUEDITHER(p, x, y, v2->color[0], \
599 v2->color[1], v2->color[2]); \
600 XMesaPutPixel(img, x, y, p); \
601 zRow[i] = z; \
602 } \
603 span.z += span.zStep; \
604 } }
605 #include "swrast/s_tritemp.h"
606
607
608
609 /*
610 * XImage, flat, depth-buffered, PF_5R6G5B triangle.
611 */
612 #define NAME flat_5R6G5B_z_triangle
613 #define INTERP_Z 1
614 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
615 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
616 #define PIXEL_TYPE GLushort
617 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
618 #define SETUP_CODE \
619 GET_XRB(xrb); \
620 GLushort p = PACK_5R6G5B( v2->color[0], v2->color[1], v2->color[2] );
621 #define RENDER_SPAN( span ) { \
622 GLuint i; \
623 for (i = 0; i < span.end; i++) { \
624 const DEPTH_TYPE z = FixedToDepth(span.z); \
625 if (z < zRow[i]) { \
626 pRow[i] = (PIXEL_TYPE) p; \
627 zRow[i] = z; \
628 } \
629 span.z += span.zStep; \
630 } }
631 #include "swrast/s_tritemp.h"
632
633
634
635 /*
636 * XImage, flat, depth-buffered, PF_DITHER_5R6G5B triangle.
637 */
638 #define NAME flat_DITHER_5R6G5B_z_triangle
639 #define INTERP_Z 1
640 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
641 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
642 #define PIXEL_TYPE GLushort
643 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
644 #define SETUP_CODE \
645 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
646 GET_XRB(xrb); \
647 const GLubyte *color = v2->color;
648 #define RENDER_SPAN( span ) { \
649 GLuint i; \
650 GLint x = span.x, y = YFLIP(xrb, span.y); \
651 for (i = 0; i < span.end; i++, x++) { \
652 const DEPTH_TYPE z = FixedToDepth(span.z); \
653 if (z < zRow[i]) { \
654 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \
655 color[GCOMP], color[BCOMP]); \
656 zRow[i] = z; \
657 } \
658 span.z += span.zStep; \
659 } }
660 #include "swrast/s_tritemp.h"
661
662
663
664 /*
665 * XImage, flat, depth-buffered, 8-bit PF_DITHER triangle.
666 */
667 #define NAME flat_DITHER8_z_triangle
668 #define INTERP_Z 1
669 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
670 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
671 #define PIXEL_TYPE GLubyte
672 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
673 #define SETUP_CODE \
674 GET_XRB(xrb); \
675 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
676 #define RENDER_SPAN( span ) { \
677 GLuint i; \
678 GLint x = span.x, y = YFLIP(xrb, span.y); \
679 FLAT_DITHER_ROW_SETUP(YFLIP(xrb, y)); \
680 for (i = 0; i < span.end; i++, x++) { \
681 const DEPTH_TYPE z = FixedToDepth(span.z); \
682 if (z < zRow[i]) { \
683 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x); \
684 zRow[i] = z; \
685 } \
686 span.z += span.zStep; \
687 } }
688 #include "swrast/s_tritemp.h"
689
690
691
692 /*
693 * XImage, flat, depth-buffered, PF_DITHER triangle.
694 */
695 #define NAME flat_DITHER_z_triangle
696 #define INTERP_Z 1
697 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
698 #define SETUP_CODE \
699 GET_XRB(xrb); \
700 XMesaImage *img = xrb->ximage; \
701 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
702 #define RENDER_SPAN( span ) { \
703 GLuint i; \
704 GLint x = span.x, y = YFLIP(xrb, span.y); \
705 FLAT_DITHER_ROW_SETUP(y); \
706 for (i = 0; i < span.end; i++, x++) { \
707 const DEPTH_TYPE z = FixedToDepth(span.z); \
708 if (z < zRow[i]) { \
709 unsigned long p = FLAT_DITHER(x); \
710 XMesaPutPixel(img, x, y, p); \
711 zRow[i] = z; \
712 } \
713 span.z += span.zStep; \
714 } }
715 #include "swrast/s_tritemp.h"
716
717
718
719 /*
720 * XImage, flat, depth-buffered, 8-bit PF_HPCR triangle.
721 */
722 #define NAME flat_HPCR_z_triangle
723 #define INTERP_Z 1
724 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
725 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
726 #define PIXEL_TYPE GLubyte
727 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
728 #define SETUP_CODE \
729 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
730 GET_XRB(xrb); \
731 GLubyte r = v2->color[0]; \
732 GLubyte g = v2->color[1]; \
733 GLubyte b = v2->color[2];
734 #define RENDER_SPAN( span ) { \
735 GLuint i; \
736 GLint x = span.x, y = YFLIP(xrb, span.y); \
737 for (i = 0; i < span.end; i++, x++) { \
738 const DEPTH_TYPE z = FixedToDepth(span.z); \
739 if (z < zRow[i]) { \
740 pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b); \
741 zRow[i] = z; \
742 } \
743 span.z += span.zStep; \
744 } }
745 #include "swrast/s_tritemp.h"
746
747
748
749 /*
750 * XImage, flat, depth-buffered, 8-bit PF_LOOKUP triangle.
751 */
752 #define NAME flat_LOOKUP8_z_triangle
753 #define INTERP_Z 1
754 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
755 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
756 #define PIXEL_TYPE GLubyte
757 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
758 #define SETUP_CODE \
759 GET_XRB(xrb); \
760 LOOKUP_SETUP; \
761 GLubyte r = v2->color[0]; \
762 GLubyte g = v2->color[1]; \
763 GLubyte b = v2->color[2]; \
764 GLubyte p = LOOKUP(r,g,b);
765 #define RENDER_SPAN( span ) { \
766 GLuint i; \
767 for (i = 0; i < span.end; i++) { \
768 const DEPTH_TYPE z = FixedToDepth(span.z); \
769 if (z < zRow[i]) { \
770 pRow[i] = p; \
771 zRow[i] = z; \
772 } \
773 span.z += span.zStep; \
774 } }
775 #include "swrast/s_tritemp.h"
776
777
778
779 /*
780 * XImage, smooth, NON-depth-buffered, PF_TRUECOLOR triangle.
781 */
782 #define NAME smooth_TRUECOLOR_triangle
783 #define INTERP_RGB 1
784 #define SETUP_CODE \
785 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
786 GET_XRB(xrb); \
787 XMesaImage *img = xrb->ximage;
788 #define RENDER_SPAN( span ) { \
789 GLuint i; \
790 GLint x = span.x, y = YFLIP(xrb, span.y); \
791 for (i = 0; i < span.end; i++, x++) { \
792 unsigned long p; \
793 PACK_TRUECOLOR(p, FixedToInt(span.red), \
794 FixedToInt(span.green), FixedToInt(span.blue)); \
795 XMesaPutPixel(img, x, y, p); \
796 span.red += span.redStep; \
797 span.green += span.greenStep; \
798 span.blue += span.blueStep; \
799 } }
800 #include "swrast/s_tritemp.h"
801
802
803
804 /*
805 * XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle.
806 */
807 #define NAME smooth_8A8B8G8R_triangle
808 #define INTERP_RGB 1
809 #define INTERP_ALPHA 1
810 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
811 #define PIXEL_TYPE GLuint
812 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
813 #define SETUP_CODE \
814 GET_XRB(xrb);
815 #define RENDER_SPAN( span ) { \
816 GLuint i; \
817 for (i = 0; i < span.end; i++) { \
818 pRow[i] = PACK_8A8B8G8R(FixedToInt(span.red), \
819 FixedToInt(span.green), FixedToInt(span.blue), \
820 FixedToInt(span.alpha)); \
821 span.red += span.redStep; \
822 span.green += span.greenStep; \
823 span.blue += span.blueStep; \
824 span.alpha += span.alphaStep; \
825 } }
826 #include "swrast/s_tritemp.h"
827
828
829
830 /*
831 * XImage, smooth, NON-depth-buffered, PF_8A8R8G8B triangle.
832 */
833 #define NAME smooth_8A8R8G8B_triangle
834 #define INTERP_RGB 1
835 #define INTERP_ALPHA 1
836 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
837 #define PIXEL_TYPE GLuint
838 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
839 #define SETUP_CODE \
840 GET_XRB(xrb);
841 #define RENDER_SPAN( span ) { \
842 GLuint i; \
843 for (i = 0; i < span.end; i++) { \
844 pRow[i] = PACK_8A8R8G8B(FixedToInt(span.red), \
845 FixedToInt(span.green), FixedToInt(span.blue), \
846 FixedToInt(span.alpha)); \
847 span.red += span.redStep; \
848 span.green += span.greenStep; \
849 span.blue += span.blueStep; \
850 span.alpha += span.alphaStep; \
851 } }
852 #include "swrast/s_tritemp.h"
853
854
855
856 /*
857 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
858 */
859 #define NAME smooth_8R8G8B_triangle
860 #define INTERP_RGB 1
861 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
862 #define PIXEL_TYPE GLuint
863 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
864 #define SETUP_CODE \
865 GET_XRB(xrb);
866 #define RENDER_SPAN( span ) { \
867 GLuint i; \
868 for (i = 0; i < span.end; i++) { \
869 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
870 FixedToInt(span.green), FixedToInt(span.blue) ); \
871 span.red += span.redStep; \
872 span.green += span.greenStep; \
873 span.blue += span.blueStep; \
874 } }
875 #include "swrast/s_tritemp.h"
876
877
878
879 /*
880 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
881 */
882 #define NAME smooth_8R8G8B24_triangle
883 #define INTERP_RGB 1
884 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
885 #define PIXEL_TYPE bgr_t
886 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
887 #define SETUP_CODE \
888 GET_XRB(xrb);
889 #define RENDER_SPAN( span ) { \
890 GLuint i; \
891 PIXEL_TYPE *pixel = pRow; \
892 for (i = 0; i < span.end; i++, pixel++) { \
893 pixel->r = FixedToInt(span.red); \
894 pixel->g = FixedToInt(span.green); \
895 pixel->b = FixedToInt(span.blue); \
896 span.red += span.redStep; \
897 span.green += span.greenStep; \
898 span.blue += span.blueStep; \
899 } }
900 #include "swrast/s_tritemp.h"
901
902
903
904 /*
905 * XImage, smooth, NON-depth-buffered, PF_TRUEDITHER triangle.
906 */
907 #define NAME smooth_TRUEDITHER_triangle
908 #define INTERP_RGB 1
909 #define SETUP_CODE \
910 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
911 GET_XRB(xrb); \
912 XMesaImage *img = xrb->ximage;
913 #define RENDER_SPAN( span ) { \
914 GLuint i; \
915 GLint x = span.x, y = YFLIP(xrb, span.y); \
916 for (i = 0; i < span.end; i++, x++) { \
917 unsigned long p; \
918 PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \
919 FixedToInt(span.green), FixedToInt(span.blue)); \
920 XMesaPutPixel(img, x, y, p ); \
921 span.red += span.redStep; \
922 span.green += span.greenStep; \
923 span.blue += span.blueStep; \
924 } }
925 #include "swrast/s_tritemp.h"
926
927
928
929 /*
930 * XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle.
931 */
932 #define NAME smooth_5R6G5B_triangle
933 #define INTERP_RGB 1
934 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
935 #define PIXEL_TYPE GLushort
936 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
937 #define SETUP_CODE \
938 GET_XRB(xrb);
939 #define RENDER_SPAN( span ) { \
940 GLuint i; \
941 for (i = 0; i < span.end; i++) { \
942 pRow[i] = (PIXEL_TYPE) PACK_5R6G5B(FixedToInt(span.red), \
943 FixedToInt(span.green), FixedToInt(span.blue)); \
944 span.red += span.redStep; \
945 span.green += span.greenStep; \
946 span.blue += span.blueStep; \
947 } }
948 #include "swrast/s_tritemp.h"
949
950
951
952 /*
953 * XImage, smooth, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
954 */
955 #define NAME smooth_DITHER_5R6G5B_triangle
956 #define INTERP_RGB 1
957 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
958 #define PIXEL_TYPE GLushort
959 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
960 #define SETUP_CODE \
961 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
962 GET_XRB(xrb);
963 #define RENDER_SPAN( span ) { \
964 GLuint i; \
965 GLint x = span.x, y = YFLIP(xrb, span.y); \
966 for (i = 0; i < span.end; i++, x++) { \
967 PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \
968 FixedToInt(span.green), FixedToInt(span.blue)); \
969 span.red += span.redStep; \
970 span.green += span.greenStep; \
971 span.blue += span.blueStep; \
972 } }
973 #include "swrast/s_tritemp.h"
974
975
976
977 /*
978 * XImage, smooth, NON-depth-buffered, 8-bit PF_DITHER triangle.
979 */
980 #define NAME smooth_DITHER8_triangle
981 #define INTERP_RGB 1
982 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
983 #define PIXEL_TYPE GLubyte
984 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
985 #define SETUP_CODE \
986 GET_XRB(xrb);
987 #define RENDER_SPAN( span ) { \
988 GLuint i; \
989 GLint x = span.x, y = YFLIP(xrb, span.y); \
990 XDITHER_SETUP(y); \
991 for (i = 0; i < span.end; i++, x++) { \
992 pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red), \
993 FixedToInt(span.green), FixedToInt(span.blue) ); \
994 span.red += span.redStep; \
995 span.green += span.greenStep; \
996 span.blue += span.blueStep; \
997 } }
998 #include "swrast/s_tritemp.h"
999
1000
1001
1002 /*
1003 * XImage, smooth, NON-depth-buffered, PF_DITHER triangle.
1004 */
1005 #define NAME smooth_DITHER_triangle
1006 #define INTERP_RGB 1
1007 #define SETUP_CODE \
1008 GET_XRB(xrb); \
1009 XMesaImage *img = xrb->ximage;
1010 #define RENDER_SPAN( span ) { \
1011 GLuint i; \
1012 GLint x = span.x, y = YFLIP(xrb, span.y); \
1013 XDITHER_SETUP(y); \
1014 for (i = 0; i < span.end; i++, x++) { \
1015 unsigned long p = XDITHER(x, FixedToInt(span.red), \
1016 FixedToInt(span.green), FixedToInt(span.blue) ); \
1017 XMesaPutPixel(img, x, y, p); \
1018 span.red += span.redStep; \
1019 span.green += span.greenStep; \
1020 span.blue += span.blueStep; \
1021 } }
1022 #include "swrast/s_tritemp.h"
1023
1024
1025
1026 /*
1027 * XImage, smooth, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
1028 */
1029 #define NAME smooth_LOOKUP8_triangle
1030 #define INTERP_RGB 1
1031 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
1032 #define PIXEL_TYPE GLubyte
1033 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1034 #define SETUP_CODE \
1035 GET_XRB(xrb);
1036 #define RENDER_SPAN( span ) { \
1037 GLuint i; \
1038 LOOKUP_SETUP; \
1039 for (i = 0; i < span.end; i++) { \
1040 pRow[i] = LOOKUP(FixedToInt(span.red), \
1041 FixedToInt(span.green), FixedToInt(span.blue)); \
1042 span.red += span.redStep; \
1043 span.green += span.greenStep; \
1044 span.blue += span.blueStep; \
1045 } }
1046 #include "swrast/s_tritemp.h"
1047
1048
1049
1050 /*
1051 * XImage, smooth, NON-depth-buffered, 8-bit PF_HPCR triangle.
1052 */
1053 #define NAME smooth_HPCR_triangle
1054 #define INTERP_RGB 1
1055 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
1056 #define PIXEL_TYPE GLubyte
1057 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1058 #define SETUP_CODE \
1059 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1060 GET_XRB(xrb);
1061 #define RENDER_SPAN( span ) { \
1062 GLuint i; \
1063 GLint x = span.x, y = YFLIP(xrb, span.y); \
1064 for (i = 0; i < span.end; i++, x++) { \
1065 pRow[i] = DITHER_HPCR(x, y, FixedToInt(span.red), \
1066 FixedToInt(span.green), FixedToInt(span.blue)); \
1067 span.red += span.redStep; \
1068 span.green += span.greenStep; \
1069 span.blue += span.blueStep; \
1070 } }
1071 #include "swrast/s_tritemp.h"
1072
1073
1074
1075 /*
1076 * XImage, flat, NON-depth-buffered, PF_TRUECOLOR triangle.
1077 */
1078 #define NAME flat_TRUECOLOR_triangle
1079 #define SETUP_CODE \
1080 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1081 GET_XRB(xrb); \
1082 XMesaImage *img = xrb->ximage; \
1083 unsigned long pixel; \
1084 PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]);
1085 #define RENDER_SPAN( span ) { \
1086 GLuint i; \
1087 GLint x = span.x, y = YFLIP(xrb, span.y); \
1088 for (i = 0; i < span.end; i++, x++) { \
1089 XMesaPutPixel(img, x, y, pixel); \
1090 } }
1091 #include "swrast/s_tritemp.h"
1092
1093
1094
1095 /*
1096 * XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle.
1097 */
1098 #define NAME flat_8A8B8G8R_triangle
1099 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
1100 #define PIXEL_TYPE GLuint
1101 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1102 #define SETUP_CODE \
1103 GET_XRB(xrb); \
1104 unsigned long p = PACK_8B8G8R( v2->color[0], \
1105 v2->color[1], v2->color[2] );
1106 #define RENDER_SPAN( span ) { \
1107 GLuint i; \
1108 for (i = 0; i < span.end; i++) { \
1109 pRow[i] = (PIXEL_TYPE) p; \
1110 } }
1111 #include "swrast/s_tritemp.h"
1112
1113
1114
1115 /*
1116 * XImage, flat, NON-depth-buffered, PF_8A8R8G8B triangle.
1117 */
1118 #define NAME flat_8A8R8G8B_triangle
1119 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
1120 #define PIXEL_TYPE GLuint
1121 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1122 #define SETUP_CODE \
1123 GET_XRB(xrb); \
1124 unsigned long p = PACK_8R8G8B( v2->color[0], \
1125 v2->color[1], v2->color[2] );
1126 #define RENDER_SPAN( span ) { \
1127 GLuint i; \
1128 for (i = 0; i < span.end; i++) { \
1129 pRow[i] = (PIXEL_TYPE) p; \
1130 } }
1131 #include "swrast/s_tritemp.h"
1132
1133
1134
1135 /*
1136 * XImage, flat, NON-depth-buffered, PF_8R8G8B triangle.
1137 */
1138 #define NAME flat_8R8G8B_triangle
1139 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
1140 #define PIXEL_TYPE GLuint
1141 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1142 #define SETUP_CODE \
1143 GET_XRB(xrb); \
1144 unsigned long p = PACK_8R8G8B( v2->color[0], \
1145 v2->color[1], v2->color[2] );
1146 #define RENDER_SPAN( span ) { \
1147 GLuint i; \
1148 for (i = 0; i < span.end; i++) { \
1149 pRow[i] = (PIXEL_TYPE) p; \
1150 } }
1151 #include "swrast/s_tritemp.h"
1152
1153
1154
1155 /*
1156 * XImage, flat, NON-depth-buffered, PF_8R8G8B24 triangle.
1157 */
1158 #define NAME flat_8R8G8B24_triangle
1159 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
1160 #define PIXEL_TYPE bgr_t
1161 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1162 #define SETUP_CODE \
1163 GET_XRB(xrb); \
1164 const GLubyte *color = v2->color;
1165 #define RENDER_SPAN( span ) { \
1166 GLuint i; \
1167 PIXEL_TYPE *pixel = pRow; \
1168 for (i = 0; i < span.end; i++, pixel++) { \
1169 pixel->r = color[RCOMP]; \
1170 pixel->g = color[GCOMP]; \
1171 pixel->b = color[BCOMP]; \
1172 } }
1173 #include "swrast/s_tritemp.h"
1174
1175
1176
1177 /*
1178 * XImage, flat, NON-depth-buffered, PF_TRUEDITHER triangle.
1179 */
1180 #define NAME flat_TRUEDITHER_triangle
1181 #define SETUP_CODE \
1182 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1183 GET_XRB(xrb); \
1184 XMesaImage *img = xrb->ximage;
1185 #define RENDER_SPAN( span ) { \
1186 GLuint i; \
1187 GLint x = span.x, y = YFLIP(xrb, span.y); \
1188 for (i = 0; i < span.end; i++, x++) { \
1189 unsigned long p; \
1190 PACK_TRUEDITHER(p, x, y, v2->color[0], \
1191 v2->color[1], v2->color[2] ); \
1192 XMesaPutPixel(img, x, y, p); \
1193 } }
1194 #include "swrast/s_tritemp.h"
1195
1196
1197
1198 /*
1199 * XImage, flat, NON-depth-buffered, PF_5R6G5B triangle.
1200 */
1201 #define NAME flat_5R6G5B_triangle
1202 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
1203 #define PIXEL_TYPE GLushort
1204 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1205 #define SETUP_CODE \
1206 GET_XRB(xrb); \
1207 unsigned long p = PACK_5R6G5B( v2->color[0], \
1208 v2->color[1], v2->color[2] );
1209 #define RENDER_SPAN( span ) { \
1210 GLuint i; \
1211 for (i = 0; i < span.end; i++) { \
1212 pRow[i] = (PIXEL_TYPE) p; \
1213 } }
1214 #include "swrast/s_tritemp.h"
1215
1216
1217
1218 /*
1219 * XImage, flat, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
1220 */
1221 #define NAME flat_DITHER_5R6G5B_triangle
1222 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
1223 #define PIXEL_TYPE GLushort
1224 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1225 #define SETUP_CODE \
1226 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1227 GET_XRB(xrb); \
1228 const GLubyte *color = v2->color;
1229 #define RENDER_SPAN( span ) { \
1230 GLuint i; \
1231 GLint x = span.x, y = YFLIP(xrb, span.y); \
1232 for (i = 0; i < span.end; i++, x++) { \
1233 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \
1234 color[GCOMP], color[BCOMP]); \
1235 } }
1236 #include "swrast/s_tritemp.h"
1237
1238
1239
1240 /*
1241 * XImage, flat, NON-depth-buffered, 8-bit PF_DITHER triangle.
1242 */
1243 #define NAME flat_DITHER8_triangle
1244 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
1245 #define PIXEL_TYPE GLubyte
1246 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1247 #define SETUP_CODE \
1248 GET_XRB(xrb); \
1249 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
1250 #define RENDER_SPAN( span ) { \
1251 GLuint i; \
1252 GLint x = span.x, y = YFLIP(xrb, span.y); \
1253 FLAT_DITHER_ROW_SETUP(YFLIP(xrb, y)); \
1254 for (i = 0; i < span.end; i++, x++) { \
1255 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x); \
1256 } }
1257 #include "swrast/s_tritemp.h"
1258
1259
1260
1261 /*
1262 * XImage, flat, NON-depth-buffered, PF_DITHER triangle.
1263 */
1264 #define NAME flat_DITHER_triangle
1265 #define SETUP_CODE \
1266 GET_XRB(xrb); \
1267 XMesaImage *img = xrb->ximage; \
1268 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
1269 #define RENDER_SPAN( span ) { \
1270 GLuint i; \
1271 GLint x = span.x, y = YFLIP(xrb, span.y); \
1272 FLAT_DITHER_ROW_SETUP(y); \
1273 for (i = 0; i < span.end; i++, x++) { \
1274 unsigned long p = FLAT_DITHER(x); \
1275 XMesaPutPixel(img, x, y, p ); \
1276 } }
1277 #include "swrast/s_tritemp.h"
1278
1279
1280
1281 /*
1282 * XImage, flat, NON-depth-buffered, 8-bit PF_HPCR triangle.
1283 */
1284 #define NAME flat_HPCR_triangle
1285 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
1286 #define PIXEL_TYPE GLubyte
1287 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1288 #define SETUP_CODE \
1289 XMesaContext xmesa = XMESA_CONTEXT(ctx); \
1290 GET_XRB(xrb); \
1291 GLubyte r = v2->color[0]; \
1292 GLubyte g = v2->color[1]; \
1293 GLubyte b = v2->color[2];
1294 #define RENDER_SPAN( span ) { \
1295 GLuint i; \
1296 GLint x = span.x, y = YFLIP(xrb, span.y); \
1297 for (i = 0; i < span.end; i++, x++) { \
1298 pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b); \
1299 } }
1300 #include "swrast/s_tritemp.h"
1301
1302
1303
1304 /*
1305 * XImage, flat, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
1306 */
1307 #define NAME flat_LOOKUP8_triangle
1308 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
1309 #define PIXEL_TYPE GLubyte
1310 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
1311 #define SETUP_CODE \
1312 GET_XRB(xrb); \
1313 LOOKUP_SETUP; \
1314 GLubyte r = v2->color[0]; \
1315 GLubyte g = v2->color[1]; \
1316 GLubyte b = v2->color[2]; \
1317 GLubyte p = LOOKUP(r,g,b);
1318 #define RENDER_SPAN( span ) { \
1319 GLuint i; \
1320 for (i = 0; i < span.end; i++) { \
1321 pRow[i] = (PIXEL_TYPE) p; \
1322 } }
1323 #include "swrast/s_tritemp.h"
1324
1325
1326 #endif /* CHAN_BITS == 8 */
1327
1328
1329 #if defined(DEBUG) && CHAN_BITS == 8
1330 extern void _xmesa_print_triangle_func( swrast_tri_func triFunc );
1331 void _xmesa_print_triangle_func( swrast_tri_func triFunc )
1332 {
1333 _mesa_printf("XMesa tri func = ");
1334 if (triFunc ==smooth_TRUECOLOR_z_triangle)
1335 _mesa_printf("smooth_TRUECOLOR_z_triangle\n");
1336 else if (triFunc ==smooth_8A8B8G8R_z_triangle)
1337 _mesa_printf("smooth_8A8B8G8R_z_triangle\n");
1338 else if (triFunc ==smooth_8A8R8G8B_z_triangle)
1339 _mesa_printf("smooth_8A8R8G8B_z_triangle\n");
1340 else if (triFunc ==smooth_8R8G8B_z_triangle)
1341 _mesa_printf("smooth_8R8G8B_z_triangle\n");
1342 else if (triFunc ==smooth_8R8G8B24_z_triangle)
1343 _mesa_printf("smooth_8R8G8B24_z_triangle\n");
1344 else if (triFunc ==smooth_TRUEDITHER_z_triangle)
1345 _mesa_printf("smooth_TRUEDITHER_z_triangle\n");
1346 else if (triFunc ==smooth_5R6G5B_z_triangle)
1347 _mesa_printf("smooth_5R6G5B_z_triangle\n");
1348 else if (triFunc ==smooth_DITHER_5R6G5B_z_triangle)
1349 _mesa_printf("smooth_DITHER_5R6G5B_z_triangle\n");
1350 else if (triFunc ==smooth_HPCR_z_triangle)
1351 _mesa_printf("smooth_HPCR_z_triangle\n");
1352 else if (triFunc ==smooth_DITHER8_z_triangle)
1353 _mesa_printf("smooth_DITHER8_z_triangle\n");
1354 else if (triFunc ==smooth_LOOKUP8_z_triangle)
1355 _mesa_printf("smooth_LOOKUP8_z_triangle\n");
1356 else if (triFunc ==flat_TRUECOLOR_z_triangle)
1357 _mesa_printf("flat_TRUECOLOR_z_triangle\n");
1358 else if (triFunc ==flat_8A8B8G8R_z_triangle)
1359 _mesa_printf("flat_8A8B8G8R_z_triangle\n");
1360 else if (triFunc ==flat_8A8R8G8B_z_triangle)
1361 _mesa_printf("flat_8A8R8G8B_z_triangle\n");
1362 else if (triFunc ==flat_8R8G8B_z_triangle)
1363 _mesa_printf("flat_8R8G8B_z_triangle\n");
1364 else if (triFunc ==flat_8R8G8B24_z_triangle)
1365 _mesa_printf("flat_8R8G8B24_z_triangle\n");
1366 else if (triFunc ==flat_TRUEDITHER_z_triangle)
1367 _mesa_printf("flat_TRUEDITHER_z_triangle\n");
1368 else if (triFunc ==flat_5R6G5B_z_triangle)
1369 _mesa_printf("flat_5R6G5B_z_triangle\n");
1370 else if (triFunc ==flat_DITHER_5R6G5B_z_triangle)
1371 _mesa_printf("flat_DITHER_5R6G5B_z_triangle\n");
1372 else if (triFunc ==flat_HPCR_z_triangle)
1373 _mesa_printf("flat_HPCR_z_triangle\n");
1374 else if (triFunc ==flat_DITHER8_z_triangle)
1375 _mesa_printf("flat_DITHER8_z_triangle\n");
1376 else if (triFunc ==flat_LOOKUP8_z_triangle)
1377 _mesa_printf("flat_LOOKUP8_z_triangle\n");
1378 else if (triFunc ==smooth_TRUECOLOR_triangle)
1379 _mesa_printf("smooth_TRUECOLOR_triangle\n");
1380 else if (triFunc ==smooth_8A8B8G8R_triangle)
1381 _mesa_printf("smooth_8A8B8G8R_triangle\n");
1382 else if (triFunc ==smooth_8A8R8G8B_triangle)
1383 _mesa_printf("smooth_8A8R8G8B_triangle\n");
1384 else if (triFunc ==smooth_8R8G8B_triangle)
1385 _mesa_printf("smooth_8R8G8B_triangle\n");
1386 else if (triFunc ==smooth_8R8G8B24_triangle)
1387 _mesa_printf("smooth_8R8G8B24_triangle\n");
1388 else if (triFunc ==smooth_TRUEDITHER_triangle)
1389 _mesa_printf("smooth_TRUEDITHER_triangle\n");
1390 else if (triFunc ==smooth_5R6G5B_triangle)
1391 _mesa_printf("smooth_5R6G5B_triangle\n");
1392 else if (triFunc ==smooth_DITHER_5R6G5B_triangle)
1393 _mesa_printf("smooth_DITHER_5R6G5B_triangle\n");
1394 else if (triFunc ==smooth_HPCR_triangle)
1395 _mesa_printf("smooth_HPCR_triangle\n");
1396 else if (triFunc ==smooth_DITHER8_triangle)
1397 _mesa_printf("smooth_DITHER8_triangle\n");
1398 else if (triFunc ==smooth_LOOKUP8_triangle)
1399 _mesa_printf("smooth_LOOKUP8_triangle\n");
1400 else if (triFunc ==flat_TRUECOLOR_triangle)
1401 _mesa_printf("flat_TRUECOLOR_triangle\n");
1402 else if (triFunc ==flat_TRUEDITHER_triangle)
1403 _mesa_printf("flat_TRUEDITHER_triangle\n");
1404 else if (triFunc ==flat_8A8B8G8R_triangle)
1405 _mesa_printf("flat_8A8B8G8R_triangle\n");
1406 else if (triFunc ==flat_8A8R8G8B_triangle)
1407 _mesa_printf("flat_8A8R8G8B_triangle\n");
1408 else if (triFunc ==flat_8R8G8B_triangle)
1409 _mesa_printf("flat_8R8G8B_triangle\n");
1410 else if (triFunc ==flat_8R8G8B24_triangle)
1411 _mesa_printf("flat_8R8G8B24_triangle\n");
1412 else if (triFunc ==flat_5R6G5B_triangle)
1413 _mesa_printf("flat_5R6G5B_triangle\n");
1414 else if (triFunc ==flat_DITHER_5R6G5B_triangle)
1415 _mesa_printf("flat_DITHER_5R6G5B_triangle\n");
1416 else if (triFunc ==flat_HPCR_triangle)
1417 _mesa_printf("flat_HPCR_triangle\n");
1418 else if (triFunc ==flat_DITHER8_triangle)
1419 _mesa_printf("flat_DITHER8_triangle\n");
1420 else if (triFunc ==flat_LOOKUP8_triangle)
1421 _mesa_printf("flat_LOOKUP8_triangle\n");
1422 else
1423 _mesa_printf("???\n");
1424 }
1425 #endif
1426
1427
1428 #ifdef DEBUG
1429
1430 /* record the current triangle function name */
1431 static const char *triFuncName = NULL;
1432
1433 #define USE(triFunc) \
1434 do { \
1435 triFuncName = #triFunc; \
1436 return triFunc; \
1437 } while (0)
1438
1439 #else
1440
1441 #define USE(triFunc) return triFunc
1442
1443 #endif
1444
1445
1446 #if 0
1447 GLboolean xmesa_get_cbuf_details( GLcontext *ctx,
1448 void **ptr,
1449 GLuint *cpp,
1450 GLint *stride,
1451 GLuint *format )
1452 {
1453 XMesaContext xmesa = XMESA_CONTEXT(ctx);
1454 struct gl_framebuffer *fb = ctx->DrawBuffer;
1455 struct gl_renderbuffer *crb = fb->_ColorDrawBuffers[0][0];
1456 struct xmesa_renderbuffer *xrb = xmesa_renderbuffer(crb->Wrapped);
1457
1458 *ptr = crb->GetPointer(ctx, crb, 0, 0);
1459 *stride = ((GLubyte *)crb->GetPointer(ctx, crb, 0, 1) -
1460 (GLubyte *)crb->GetPointer(ctx, crb, 0, 0));
1461
1462 if (!ptr)
1463 goto bad;
1464
1465 switch (xmesa->pixelformat) {
1466 case PF_8A8B8G8R:
1467 case PF_8A8R8G8B:
1468 *format = 1; /* whatever */
1469 *cpp = 4;
1470 break;
1471 default:
1472 goto bad;
1473 }
1474
1475 return GL_TRUE;
1476
1477 bad:
1478 *ptr = NULL;
1479 *stride = 0;
1480 *format = 0;
1481 return GL_FALSE;
1482 }
1483 #endif
1484
1485
1486 /**
1487 * Return pointer to line drawing function, or NULL if we should use a
1488 * swrast fallback.
1489 */
1490 static swrast_tri_func
1491 get_triangle_func(GLcontext *ctx)
1492 {
1493 #if CHAN_BITS == 8
1494 SWcontext *swrast = SWRAST_CONTEXT(ctx);
1495 XMesaContext xmesa = XMESA_CONTEXT(ctx);
1496 XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer);
1497 const int depth = GET_VISUAL_DEPTH(xmesa->xm_visual);
1498 const struct xmesa_renderbuffer *xrb;
1499
1500 #ifdef DEBUG
1501 triFuncName = NULL;
1502 #endif
1503
1504 /* trivial fallback tests */
1505 if ((ctx->DrawBuffer->_ColorDrawBufferIndexes[0] != BUFFER_BIT_FRONT_LEFT) &&
1506 (ctx->DrawBuffer->_ColorDrawBufferIndexes[0] != BUFFER_BIT_BACK_LEFT))
1507 return (swrast_tri_func) NULL;
1508 if (ctx->RenderMode != GL_RENDER)
1509 return (swrast_tri_func) NULL;
1510 if (ctx->Polygon.SmoothFlag)
1511 return (swrast_tri_func) NULL;
1512 if (ctx->Texture._EnabledUnits)
1513 return (swrast_tri_func) NULL;
1514 if (swrast->_RasterMask & MULTI_DRAW_BIT)
1515 return (swrast_tri_func) NULL;
1516 if (ctx->Polygon.CullFlag &&
1517 ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
1518 return (swrast_tri_func) NULL;
1519 if (xmbuf->swAlpha)
1520 return (swrast_tri_func) NULL;
1521
1522 xrb = xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0]->Wrapped);
1523
1524 if (xrb->ximage) {
1525 if ( ctx->Light.ShadeModel==GL_SMOOTH
1526 && swrast->_RasterMask==DEPTH_BIT
1527 && ctx->Depth.Func==GL_LESS
1528 && ctx->Depth.Mask==GL_TRUE
1529 && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
1530 && ctx->Polygon.StippleFlag==GL_FALSE) {
1531 switch (xmesa->pixelformat) {
1532 case PF_Truecolor:
1533 USE(smooth_TRUECOLOR_z_triangle);
1534 case PF_8A8B8G8R:
1535 USE(smooth_8A8B8G8R_z_triangle);
1536 case PF_8A8R8G8B:
1537 USE(smooth_8A8R8G8B_z_triangle);
1538 case PF_8R8G8B:
1539 USE(smooth_8R8G8B_z_triangle);
1540 case PF_8R8G8B24:
1541 USE(smooth_8R8G8B24_z_triangle);
1542 case PF_Dither_True:
1543 USE(smooth_TRUEDITHER_z_triangle);
1544 case PF_5R6G5B:
1545 USE(smooth_5R6G5B_z_triangle);
1546 case PF_Dither_5R6G5B:
1547 USE(smooth_DITHER_5R6G5B_z_triangle);
1548 case PF_HPCR:
1549 USE(smooth_HPCR_z_triangle);
1550 case PF_Dither:
1551 if (depth == 8)
1552 USE(smooth_DITHER8_z_triangle);
1553 else
1554 USE(smooth_DITHER_z_triangle);
1555 case PF_Lookup:
1556 if (depth == 8)
1557 USE(smooth_LOOKUP8_z_triangle);
1558 else
1559 return (swrast_tri_func) NULL;
1560 default:
1561 return (swrast_tri_func) NULL;
1562 }
1563 }
1564 if ( ctx->Light.ShadeModel==GL_FLAT
1565 && swrast->_RasterMask==DEPTH_BIT
1566 && ctx->Depth.Func==GL_LESS
1567 && ctx->Depth.Mask==GL_TRUE
1568 && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
1569 && ctx->Polygon.StippleFlag==GL_FALSE) {
1570 switch (xmesa->pixelformat) {
1571 case PF_Truecolor:
1572 USE(flat_TRUECOLOR_z_triangle);
1573 case PF_8A8B8G8R:
1574 USE(flat_8A8B8G8R_z_triangle);
1575 case PF_8A8R8G8B:
1576 USE(flat_8A8R8G8B_z_triangle);
1577 case PF_8R8G8B:
1578 USE(flat_8R8G8B_z_triangle);
1579 case PF_8R8G8B24:
1580 USE(flat_8R8G8B24_z_triangle);
1581 case PF_Dither_True:
1582 USE(flat_TRUEDITHER_z_triangle);
1583 case PF_5R6G5B:
1584 USE(flat_5R6G5B_z_triangle);
1585 case PF_Dither_5R6G5B:
1586 USE(flat_DITHER_5R6G5B_z_triangle);
1587 case PF_HPCR:
1588 USE(flat_HPCR_z_triangle);
1589 case PF_Dither:
1590 if (depth == 8)
1591 USE(flat_DITHER8_z_triangle);
1592 else
1593 USE(flat_DITHER_z_triangle);
1594 case PF_Lookup:
1595 if (depth == 8)
1596 USE(flat_LOOKUP8_z_triangle);
1597 else
1598 return (swrast_tri_func) NULL;
1599 default:
1600 return (swrast_tri_func) NULL;
1601 }
1602 }
1603 if ( swrast->_RasterMask==0 /* no depth test */
1604 && ctx->Light.ShadeModel==GL_SMOOTH
1605 && ctx->Polygon.StippleFlag==GL_FALSE) {
1606 switch (xmesa->pixelformat) {
1607 case PF_Truecolor:
1608 USE(smooth_TRUECOLOR_triangle);
1609 case PF_8A8B8G8R:
1610 USE(smooth_8A8B8G8R_triangle);
1611 case PF_8A8R8G8B:
1612 USE(smooth_8A8R8G8B_triangle);
1613 case PF_8R8G8B:
1614 USE(smooth_8R8G8B_triangle);
1615 case PF_8R8G8B24:
1616 USE(smooth_8R8G8B24_triangle);
1617 case PF_Dither_True:
1618 USE(smooth_TRUEDITHER_triangle);
1619 case PF_5R6G5B:
1620 USE(smooth_5R6G5B_triangle);
1621 case PF_Dither_5R6G5B:
1622 USE(smooth_DITHER_5R6G5B_triangle);
1623 case PF_HPCR:
1624 USE(smooth_HPCR_triangle);
1625 case PF_Dither:
1626 if (depth == 8)
1627 USE(smooth_DITHER8_triangle);
1628 else
1629 USE(smooth_DITHER_triangle);
1630 case PF_Lookup:
1631 if (depth == 8)
1632 USE(smooth_LOOKUP8_triangle);
1633 else
1634 return (swrast_tri_func) NULL;
1635 default:
1636 return (swrast_tri_func) NULL;
1637 }
1638 }
1639
1640 if ( swrast->_RasterMask==0 /* no depth test */
1641 && ctx->Light.ShadeModel==GL_FLAT
1642 && ctx->Polygon.StippleFlag==GL_FALSE) {
1643 switch (xmesa->pixelformat) {
1644 case PF_Truecolor:
1645 USE(flat_TRUECOLOR_triangle);
1646 case PF_Dither_True:
1647 USE(flat_TRUEDITHER_triangle);
1648 case PF_8A8B8G8R:
1649 USE(flat_8A8B8G8R_triangle);
1650 case PF_8A8R8G8B:
1651 USE(flat_8A8R8G8B_triangle);
1652 case PF_8R8G8B:
1653 USE(flat_8R8G8B_triangle);
1654 case PF_8R8G8B24:
1655 USE(flat_8R8G8B24_triangle);
1656 case PF_5R6G5B:
1657 USE(flat_5R6G5B_triangle);
1658 case PF_Dither_5R6G5B:
1659 USE(flat_DITHER_5R6G5B_triangle);
1660 case PF_HPCR:
1661 USE(flat_HPCR_triangle);
1662 case PF_Dither:
1663 if (depth == 8)
1664 USE(flat_DITHER8_triangle);
1665 else
1666 USE(flat_DITHER_triangle);
1667 case PF_Lookup:
1668 if (depth == 8)
1669 USE(flat_LOOKUP8_triangle);
1670 else
1671 return (swrast_tri_func) NULL;
1672 default:
1673 return (swrast_tri_func) NULL;
1674 }
1675 }
1676 }
1677 #endif /* CHAN_BITS == 8 */
1678
1679 return (swrast_tri_func) NULL;
1680 }
1681
1682
1683 /* Override for the swrast tri-selection function. Try to use one
1684 * of our internal tri functions, otherwise fall back to the
1685 * standard swrast functions.
1686 */
1687 void xmesa_choose_triangle( GLcontext *ctx )
1688 {
1689 SWcontext *swrast = SWRAST_CONTEXT(ctx);
1690
1691 if (!(swrast->Triangle = get_triangle_func( ctx )))
1692 _swrast_choose_triangle( ctx );
1693 }
1694