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