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