projects / mesa.git / blob
? search:


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