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