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