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