projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
replaced __inline with INLINE
[mesa.git] / src / mesa / swrast / s_linetemp.h
1 /* $Id: s_linetemp.h,v 1.8 2001/05/03 22:13:32 brianp Exp $ */
2
3 /*
4 * Mesa 3-D graphics library
5 * Version: 3.5
6 *
7 * Copyright (C) 1999-2001 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 * Line Rasterizer Template
30 *
31 * This file is #include'd to generate custom line rasterizers.
32 *
33 * The following macros may be defined to indicate what auxillary information
34 * must be interplated along the line:
35 * INTERP_Z - if defined, interpolate Z values
36 * INTERP_FOG - if defined, interpolate FOG values
37 * INTERP_RGB - if defined, interpolate RGB values
38 * INTERP_SPEC - if defined, interpolate specular RGB values
39 * INTERP_ALPHA - if defined, interpolate Alpha values
40 * INTERP_INDEX - if defined, interpolate color index values
41 * INTERP_TEX - if defined, interpolate unit 0 texcoords
42 * INTERP_MULTITEX - if defined, interpolate multi-texcoords
43 *
44 * When one can directly address pixels in the color buffer the following
45 * macros can be defined and used to directly compute pixel addresses during
46 * rasterization (see pixelPtr):
47 * PIXEL_TYPE - the datatype of a pixel (GLubyte, GLushort, GLuint)
48 * BYTES_PER_ROW - number of bytes per row in the color buffer
49 * PIXEL_ADDRESS(X,Y) - returns the address of pixel at (X,Y) where
50 * Y==0 at bottom of screen and increases upward.
51 *
52 * Similarly, for direct depth buffer access, this type is used for depth
53 * buffer addressing:
54 * DEPTH_TYPE - either GLushort or GLuint
55 *
56 * Optionally, one may provide one-time setup code
57 * SETUP_CODE - code which is to be executed once per line
58 *
59 * To enable line stippling define STIPPLE = 1
60 * To enable wide lines define WIDE = 1
61 *
62 * To actually "plot" each pixel either the PLOT macro or
63 * (XMAJOR_PLOT and YMAJOR_PLOT macros) must be defined...
64 * PLOT(X,Y) - code to plot a pixel. Example:
65 * if (Z < *zPtr) {
66 * *zPtr = Z;
67 * color = pack_rgb( FixedToInt(r0), FixedToInt(g0),
68 * FixedToInt(b0) );
69 * put_pixel( X, Y, color );
70 * }
71 *
72 * This code was designed for the origin to be in the lower-left corner.
73 *
74 */
75
76
77 /*void line( GLcontext *ctx, const SWvertex *vert0, const SWvertex *vert1 )*/
78 {
79 GLint x0 = (GLint) vert0->win[0];
80 GLint x1 = (GLint) vert1->win[0];
81 GLint y0 = (GLint) vert0->win[1];
82 GLint y1 = (GLint) vert1->win[1];
83 GLint dx, dy;
84 #ifdef INTERP_XY
85 GLint xstep, ystep;
86 #endif
87 #ifdef INTERP_Z
88 GLint z0, z1, dz;
89 const GLint depthBits = ctx->Visual.depthBits;
90 const GLint fixedToDepthShift = depthBits <= 16 ? FIXED_SHIFT : 0;
91 # define FixedToDepth(F) ((F) >> fixedToDepthShift)
92 # ifdef DEPTH_TYPE
93 GLint zPtrXstep, zPtrYstep;
94 DEPTH_TYPE *zPtr;
95 # endif
96 #endif
97 #ifdef INTERP_FOG
98 GLfloat fog0 = vert0->fog;
99 GLfloat dfog = vert1->fog - fog0;
100 #endif
101 #ifdef INTERP_RGB
102 GLfixed r0 = IntToFixed(vert0->color[0]);
103 GLfixed dr = IntToFixed(vert1->color[0]) - r0;
104 GLfixed g0 = IntToFixed(vert0->color[1]);
105 GLfixed dg = IntToFixed(vert1->color[1]) - g0;
106 GLfixed b0 = IntToFixed(vert0->color[2]);
107 GLfixed db = IntToFixed(vert1->color[2]) - b0;
108 #endif
109 #ifdef INTERP_SPEC
110 GLfixed sr0 = IntToFixed(vert0->specular[0]);
111 GLfixed dsr = IntToFixed(vert1->specular[0]) - sr0;
112 GLfixed sg0 = IntToFixed(vert0->specular[1]);
113 GLfixed dsg = IntToFixed(vert1->specular[1]) - sg0;
114 GLfixed sb0 = IntToFixed(vert0->specular[2]);
115 GLfixed dsb = IntToFixed(vert1->specular[2]) - sb0;
116 #endif
117 #ifdef INTERP_ALPHA
118 GLfixed a0 = IntToFixed(vert0->color[3]);
119 GLfixed da = IntToFixed(vert1->color[3]) - a0;
120 #endif
121 #ifdef INTERP_INDEX
122 GLint i0 = vert0->index << 8;
123 GLint di = (GLint) (vert1->index << 8) - i0;
124 #endif
125 #ifdef INTERP_TEX
126 const GLfloat invw0 = vert0->win[3];
127 const GLfloat invw1 = vert1->win[3];
128 GLfloat tex[4];
129 GLfloat dtex[4];
130 GLfloat fragTexcoord[4];
131 #endif
132 #ifdef INTERP_MULTITEX
133 const GLfloat invw0 = vert0->win[3];
134 const GLfloat invw1 = vert1->win[3];
135 GLfloat tex[MAX_TEXTURE_UNITS][4];
136 GLfloat dtex[MAX_TEXTURE_UNITS][4];
137 GLfloat fragTexcoord[MAX_TEXTURE_UNITS][4];
138 #endif
139 #ifdef PIXEL_ADDRESS
140 PIXEL_TYPE *pixelPtr;
141 GLint pixelXstep, pixelYstep;
142 #endif
143 #ifdef STIPPLE
144 SWcontext *swrast = SWRAST_CONTEXT(ctx);
145 #endif
146 #ifdef WIDE
147 /* for wide lines, draw all X in [x+min, x+max] or Y in [y+min, y+max] */
148 GLint width, min, max;
149 width = (GLint) CLAMP( ctx->Line.Width, MIN_LINE_WIDTH, MAX_LINE_WIDTH );
150 min = (width-1) / -2;
151 max = min + width - 1;
152 #endif
153 #ifdef INTERP_TEX
154 {
155 tex[0] = invw0 * vert0->texcoord[0][0];
156 dtex[0] = invw1 * vert1->texcoord[0][0] - tex[0];
157 tex[1] = invw0 * vert0->texcoord[0][1];
158 dtex[1] = invw1 * vert1->texcoord[0][1] - tex[1];
159 tex[2] = invw0 * vert0->texcoord[0][2];
160 dtex[2] = invw1 * vert1->texcoord[0][2] - tex[2];
161 tex[3] = invw0 * vert0->texcoord[0][3];
162 dtex[3] = invw1 * vert1->texcoord[0][3] - tex[3];
163 }
164 #endif
165 #ifdef INTERP_MULTITEX
166 {
167 GLuint u;
168 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
169 if (ctx->Texture.Unit[u]._ReallyEnabled) {
170 tex[u][0] = invw0 * vert0->texcoord[u][0];
171 dtex[u][0] = invw1 * vert1->texcoord[u][0] - tex[u][0];
172 tex[u][1] = invw0 * vert0->texcoord[u][1];
173 dtex[u][1] = invw1 * vert1->texcoord[u][1] - tex[u][1];
174 tex[u][2] = invw0 * vert0->texcoord[u][2];
175 dtex[u][2] = invw1 * vert1->texcoord[u][2] - tex[u][2];
176 tex[u][3] = invw0 * vert0->texcoord[u][3];
177 dtex[u][3] = invw1 * vert1->texcoord[u][3] - tex[u][3];
178 }
179 }
180 }
181 #endif
182
183
184 /*
185 * Despite being clipped to the view volume, the line's window coordinates
186 * may just lie outside the window bounds. That is, if the legal window
187 * coordinates are [0,W-1][0,H-1], it's possible for x==W and/or y==H.
188 * This quick and dirty code nudges the endpoints inside the window if
189 * necessary.
190 */
191 #ifdef CLIP_HACK
192 {
193 GLint w = ctx->DrawBuffer->Width;
194 GLint h = ctx->DrawBuffer->Height;
195 if ((x0==w) | (x1==w)) {
196 if ((x0==w) & (x1==w))
197 return;
198 x0 -= x0==w;
199 x1 -= x1==w;
200 }
201 if ((y0==h) | (y1==h)) {
202 if ((y0==h) & (y1==h))
203 return;
204 y0 -= y0==h;
205 y1 -= y1==h;
206 }
207 }
208 #endif
209 dx = x1 - x0;
210 dy = y1 - y0;
211 if (dx==0 && dy==0) {
212 return;
213 }
214
215 /*
216 * Setup
217 */
218 #ifdef SETUP_CODE
219 SETUP_CODE
220 #endif
221
222 #ifdef INTERP_Z
223 # ifdef DEPTH_TYPE
224 zPtr = (DEPTH_TYPE *) _mesa_zbuffer_address(ctx, x0, y0);
225 # endif
226 if (depthBits <= 16) {
227 z0 = FloatToFixed(vert0->win[2]);
228 z1 = FloatToFixed(vert1->win[2]);
229 }
230 else {
231 z0 = (int) vert0->win[2];
232 z1 = (int) vert1->win[2];
233 }
234 #endif
235 #ifdef PIXEL_ADDRESS
236 pixelPtr = (PIXEL_TYPE *) PIXEL_ADDRESS(x0,y0);
237 #endif
238
239 if (dx<0) {
240 dx = -dx; /* make positive */
241 #ifdef INTERP_XY
242 xstep = -1;
243 #endif
244 #if defined(INTERP_Z) && defined(DEPTH_TYPE)
245 zPtrXstep = -((GLint)sizeof(DEPTH_TYPE));
246 #endif
247 #ifdef PIXEL_ADDRESS
248 pixelXstep = -((GLint)sizeof(PIXEL_TYPE));
249 #endif
250 }
251 else {
252 #ifdef INTERP_XY
253 xstep = 1;
254 #endif
255 #if defined(INTERP_Z) && defined(DEPTH_TYPE)
256 zPtrXstep = ((GLint)sizeof(DEPTH_TYPE));
257 #endif
258 #ifdef PIXEL_ADDRESS
259 pixelXstep = ((GLint)sizeof(PIXEL_TYPE));
260 #endif
261 }
262
263 if (dy<0) {
264 dy = -dy; /* make positive */
265 #ifdef INTERP_XY
266 ystep = -1;
267 #endif
268 #if defined(INTERP_Z) && defined(DEPTH_TYPE)
269 zPtrYstep = -ctx->DrawBuffer->Width * ((GLint)sizeof(DEPTH_TYPE));
270 #endif
271 #ifdef PIXEL_ADDRESS
272 pixelYstep = BYTES_PER_ROW;
273 #endif
274 }
275 else {
276 #ifdef INTERP_XY
277 ystep = 1;
278 #endif
279 #if defined(INTERP_Z) && defined(DEPTH_TYPE)
280 zPtrYstep = ctx->DrawBuffer->Width * ((GLint)sizeof(DEPTH_TYPE));
281 #endif
282 #ifdef PIXEL_ADDRESS
283 pixelYstep = -(BYTES_PER_ROW);
284 #endif
285 }
286
287 /*
288 * Draw
289 */
290
291 if (dx>dy) {
292 /*** X-major line ***/
293 GLint i;
294 GLint errorInc = dy+dy;
295 GLint error = errorInc-dx;
296 GLint errorDec = error-dx;
297 #ifdef INTERP_Z
298 dz = (z1-z0) / dx;
299 #endif
300 #ifdef INTERP_FOG
301 dfog /= dx;
302 #endif
303 #ifdef INTERP_RGB
304 dr /= dx; /* convert from whole line delta to per-pixel delta */
305 dg /= dx;
306 db /= dx;
307 #endif
308 #ifdef INTERP_SPEC
309 dsr /= dx; /* convert from whole line delta to per-pixel delta */
310 dsg /= dx;
311 dsb /= dx;
312 #endif
313 #ifdef INTERP_ALPHA
314 da /= dx;
315 #endif
316 #ifdef INTERP_INDEX
317 di /= dx;
318 #endif
319 #ifdef INTERP_TEX
320 {
321 const GLfloat invDx = 1.0F / (GLfloat) dx;
322 dtex[0] *= invDx;
323 dtex[1] *= invDx;
324 dtex[2] *= invDx;
325 dtex[3] *= invDx;
326 }
327 #endif
328 #ifdef INTERP_MULTITEX
329 {
330 const GLfloat invDx = 1.0F / (GLfloat) dx;
331 GLuint u;
332 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
333 if (ctx->Texture.Unit[u]._ReallyEnabled) {
334 dtex[u][0] *= invDx;
335 dtex[u][1] *= invDx;
336 dtex[u][2] *= invDx;
337 dtex[u][3] *= invDx;
338 }
339 }
340 }
341 #endif
342
343 for (i=0;i<dx;i++) {
344 #ifdef STIPPLE
345 GLushort m;
346 m = 1 << ((swrast->StippleCounter/ctx->Line.StippleFactor) & 0xf);
347 if (ctx->Line.StipplePattern & m) {
348 #endif
349 #ifdef INTERP_Z
350 GLdepth Z = FixedToDepth(z0);
351 #endif
352 #ifdef INTERP_INDEX
353 GLint I = i0 >> 8;
354 #endif
355 #ifdef INTERP_TEX
356 {
357 const GLfloat invQ = tex[3] ? (1.0F / tex[3]) : 1.0F;
358 fragTexcoord[0] = tex[0] * invQ;
359 fragTexcoord[1] = tex[1] * invQ;
360 fragTexcoord[2] = tex[2] * invQ;
361 fragTexcoord[3] = tex[3];
362 }
363 #endif
364 #ifdef INTERP_MULTITEX
365 {
366 GLuint u;
367 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
368 if (ctx->Texture.Unit[u]._ReallyEnabled) {
369 const GLfloat invQ = 1.0F / tex[u][3];
370 fragTexcoord[u][0] = tex[u][0] * invQ;
371 fragTexcoord[u][1] = tex[u][1] * invQ;
372 fragTexcoord[u][2] = tex[u][2] * invQ;
373 fragTexcoord[u][3] = tex[u][3];
374 }
375 }
376 }
377 #endif
378 #ifdef WIDE
379 {
380 GLint yy;
381 GLint ymin = y0 + min;
382 GLint ymax = y0 + max;
383 for (yy=ymin;yy<=ymax;yy++) {
384 PLOT( x0, yy );
385 }
386 }
387 #else
388 # ifdef XMAJOR_PLOT
389 XMAJOR_PLOT( x0, y0 );
390 # else
391 PLOT( x0, y0 );
392 # endif
393 #endif /*WIDE*/
394 #ifdef STIPPLE
395 }
396 swrast->StippleCounter++;
397 #endif
398 #ifdef INTERP_XY
399 x0 += xstep;
400 #endif
401 #ifdef INTERP_Z
402 # ifdef DEPTH_TYPE
403 zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrXstep);
404 # endif
405 z0 += dz;
406 #endif
407 #ifdef INTERP_FOG
408 fog0 += dfog;
409 #endif
410 #ifdef INTERP_RGB
411 r0 += dr;
412 g0 += dg;
413 b0 += db;
414 #endif
415 #ifdef INTERP_SPEC
416 sr0 += dsr;
417 sg0 += dsg;
418 sb0 += dsb;
419 #endif
420 #ifdef INTERP_ALPHA
421 a0 += da;
422 #endif
423 #ifdef INTERP_INDEX
424 i0 += di;
425 #endif
426 #ifdef INTERP_TEX
427 tex[0] += dtex[0];
428 tex[1] += dtex[1];
429 tex[2] += dtex[2];
430 tex[3] += dtex[3];
431 #endif
432 #ifdef INTERP_MULTITEX
433 {
434 GLuint u;
435 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
436 if (ctx->Texture.Unit[u]._ReallyEnabled) {
437 tex[u][0] += dtex[u][0];
438 tex[u][1] += dtex[u][1];
439 tex[u][2] += dtex[u][2];
440 tex[u][3] += dtex[u][3];
441 }
442 }
443 }
444 #endif
445
446 #ifdef PIXEL_ADDRESS
447 pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelXstep);
448 #endif
449 if (error<0) {
450 error += errorInc;
451 }
452 else {
453 error += errorDec;
454 #ifdef INTERP_XY
455 y0 += ystep;
456 #endif
457 #if defined(INTERP_Z) && defined(DEPTH_TYPE)
458 zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrYstep);
459 #endif
460 #ifdef PIXEL_ADDRESS
461 pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelYstep);
462 #endif
463 }
464 }
465 }
466 else {
467 /*** Y-major line ***/
468 GLint i;
469 GLint errorInc = dx+dx;
470 GLint error = errorInc-dy;
471 GLint errorDec = error-dy;
472 #ifdef INTERP_Z
473 dz = (z1-z0) / dy;
474 #endif
475 #ifdef INTERP_FOG
476 dfog /= dy;
477 #endif
478 #ifdef INTERP_RGB
479 dr /= dy; /* convert from whole line delta to per-pixel delta */
480 dg /= dy;
481 db /= dy;
482 #endif
483 #ifdef INTERP_SPEC
484 dsr /= dy; /* convert from whole line delta to per-pixel delta */
485 dsg /= dy;
486 dsb /= dy;
487 #endif
488 #ifdef INTERP_ALPHA
489 da /= dy;
490 #endif
491 #ifdef INTERP_INDEX
492 di /= dy;
493 #endif
494 #ifdef INTERP_TEX
495 {
496 const GLfloat invDy = 1.0F / (GLfloat) dy;
497 dtex[0] *= invDy;
498 dtex[1] *= invDy;
499 dtex[2] *= invDy;
500 dtex[3] *= invDy;
501 }
502 #endif
503 #ifdef INTERP_MULTITEX
504 {
505 const GLfloat invDy = 1.0F / (GLfloat) dy;
506 GLuint u;
507 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
508 if (ctx->Texture.Unit[u]._ReallyEnabled) {
509 dtex[u][0] *= invDy;
510 dtex[u][1] *= invDy;
511 dtex[u][2] *= invDy;
512 dtex[u][3] *= invDy;
513 }
514 }
515 }
516 #endif
517
518 for (i=0;i<dy;i++) {
519 #ifdef STIPPLE
520 GLushort m;
521 m = 1 << ((swrast->StippleCounter/ctx->Line.StippleFactor) & 0xf);
522 if (ctx->Line.StipplePattern & m) {
523 #endif
524 #ifdef INTERP_Z
525 GLdepth Z = FixedToDepth(z0);
526 #endif
527 #ifdef INTERP_INDEX
528 GLint I = i0 >> 8;
529 #endif
530 #ifdef INTERP_TEX
531 {
532 const GLfloat invQ = tex[3] ? (1.0F / tex[3]) : 1.0F;
533 fragTexcoord[0] = tex[0] * invQ;
534 fragTexcoord[1] = tex[1] * invQ;
535 fragTexcoord[2] = tex[2] * invQ;
536 fragTexcoord[3] = tex[3];
537 }
538 #endif
539 #ifdef INTERP_MULTITEX
540 {
541 GLuint u;
542 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
543 if (ctx->Texture.Unit[u]._ReallyEnabled) {
544 const GLfloat invQ = 1.0F / tex[u][3];
545 fragTexcoord[u][0] = tex[u][0] * invQ;
546 fragTexcoord[u][1] = tex[u][1] * invQ;
547 fragTexcoord[u][2] = tex[u][2] * invQ;
548 fragTexcoord[u][3] = tex[u][3];
549 }
550 }
551 }
552 #endif
553 #ifdef WIDE
554 {
555 GLint xx;
556 GLint xmin = x0 + min;
557 GLint xmax = x0 + max;
558 for (xx=xmin;xx<=xmax;xx++) {
559 PLOT( xx, y0 );
560 }
561 }
562 #else
563 # ifdef YMAJOR_PLOT
564 YMAJOR_PLOT( x0, y0 );
565 # else
566 PLOT( x0, y0 );
567 # endif
568 #endif /*WIDE*/
569 #ifdef STIPPLE
570 }
571 swrast->StippleCounter++;
572 #endif
573 #ifdef INTERP_XY
574 y0 += ystep;
575 #endif
576 #ifdef INTERP_Z
577 # ifdef DEPTH_TYPE
578 zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrYstep);
579 # endif
580 z0 += dz;
581 #endif
582 #ifdef INTERP_FOG
583 fog0 += dfog;
584 #endif
585 #ifdef INTERP_RGB
586 r0 += dr;
587 g0 += dg;
588 b0 += db;
589 #endif
590 #ifdef INTERP_SPEC
591 sr0 += dsr;
592 sg0 += dsg;
593 sb0 += dsb;
594 #endif
595 #ifdef INTERP_ALPHA
596 a0 += da;
597 #endif
598 #ifdef INTERP_INDEX
599 i0 += di;
600 #endif
601 #ifdef INTERP_TEX
602 tex[0] += dtex[0];
603 tex[1] += dtex[1];
604 tex[2] += dtex[2];
605 tex[3] += dtex[3];
606 #endif
607 #ifdef INTERP_MULTITEX
608 {
609 GLuint u;
610 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
611 if (ctx->Texture.Unit[u]._ReallyEnabled) {
612 tex[u][0] += dtex[u][0];
613 tex[u][1] += dtex[u][1];
614 tex[u][2] += dtex[u][2];
615 tex[u][3] += dtex[u][3];
616 }
617 }
618 }
619 #endif
620 #ifdef PIXEL_ADDRESS
621 pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelYstep);
622 #endif
623 if (error<0) {
624 error += errorInc;
625 }
626 else {
627 error += errorDec;
628 #ifdef INTERP_XY
629 x0 += xstep;
630 #endif
631 #if defined(INTERP_Z) && defined(DEPTH_TYPE)
632 zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrXstep);
633 #endif
634 #ifdef PIXEL_ADDRESS
635 pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelXstep);
636 #endif
637 }
638 }
639 }
640
641 }
642
643
644 #undef INTERP_XY
645 #undef INTERP_Z
646 #undef INTERP_FOG
647 #undef INTERP_RGB
648 #undef INTERP_SPEC
649 #undef INTERP_ALPHA
650 #undef INTERP_TEX
651 #undef INTERP_MULTITEX
652 #undef INTERP_INDEX
653 #undef PIXEL_ADDRESS
654 #undef PIXEL_TYPE
655 #undef DEPTH_TYPE
656 #undef BYTES_PER_ROW
657 #undef SETUP_CODE
658 #undef PLOT
659 #undef XMAJOR_PLOT
660 #undef YMAJOR_PLOT
661 #undef CLIP_HACK
662 #undef STIPPLE
663 #undef WIDE
664 #undef FixedToDepth