src/mesa/drivers/x11/xm_line.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5
   4  *
   5  * Copyright (C) 1999-2006  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" point, line, and triangle functions.
  28  * It should be fairly easy to write new special-purpose point, line or
  29  * triangle functions and hook them into this module.
  30  */
  31
  32
  33 #include "glxheader.h"
  34 #include "main/depth.h"
  35 #include "main/macros.h"
  36 #include "main/mtypes.h"
  37 #include "xmesaP.h"
  38
  39 /* Internal swrast includes:
  40  */
  41 #include "swrast/s_depth.h"
  42 #include "swrast/s_points.h"
  43 #include "swrast/s_lines.h"
  44 #include "swrast/s_context.h"
  45
  46
  47 /**********************************************************************/
  48 /***                    Point rendering                             ***/
  49 /**********************************************************************/
  50
  51
  52 /*
  53  * Render an array of points into a pixmap, any pixel format.
  54  */
  55 #if 000
  56 /* XXX don't use this, it doesn't dither correctly */
  57 static void draw_points_ANY_pixmap( struct gl_context *ctx, const SWvertex *vert )
  58 {
  59    XMesaContext xmesa = XMESA_CONTEXT(ctx);
  60    XMesaDisplay *dpy = xmesa->xm_visual->display;
  61    XMesaDrawable buffer = xmesa->xm_buffer->buffer;
  62    XMesaGC gc = xmesa->xm_buffer->gc;
  63
  64    if (xmesa->xm_visual->mesa_visual.RGBAflag) {
  65       register int x, y;
  66       const GLubyte *color = vert->color;
  67       unsigned long pixel = xmesa_color_to_pixel( xmesa,
  68                                                   color[0], color[1],
  69                                                   color[2], color[3],
  70                                                   xmesa->pixelformat);
  71       XMesaSetForeground( dpy, gc, pixel );
  72       x = (GLint) vert->win[0];
  73       y = YFLIP( xrb, (GLint) vert->win[1] );
  74       XMesaDrawPoint( dpy, buffer, gc, x, y);
  75    }
  76    else {
  77       /* Color index mode */
  78       register int x, y;
  79       XMesaSetForeground( dpy, gc, vert->index );
  80       x =                         (GLint) vert->win[0];
  81       y = YFLIP( xrb, (GLint) vert->win[1] );
  82       XMesaDrawPoint( dpy, buffer, gc, x, y);
  83    }
  84 }
  85 #endif
  86
  87
  88 /* Override the swrast point-selection function.  Try to use one of
  89  * our internal point functions, otherwise fall back to the standard
  90  * swrast functions.
  91  */
  92 void xmesa_choose_point( struct gl_context *ctx )
  93 {
  94 #if 0
  95    XMesaContext xmesa = XMESA_CONTEXT(ctx);
  96    SWcontext *swrast = SWRAST_CONTEXT(ctx);
  97
  98    if (ctx->RenderMode == GL_RENDER
  99        && ctx->Point.Size == 1.0F && !ctx->Point.SmoothFlag
 100        && swrast->_RasterMask == 0
 101        && !ctx->Texture._EnabledUnits
 102        && xmesa->xm_buffer->buffer != XIMAGE) {
 103       swrast->Point = draw_points_ANY_pixmap;
 104    }
 105    else {
 106       _swrast_choose_point( ctx );
 107    }
 108 #else
 109    _swrast_choose_point( ctx );
 110 #endif
 111 }
 112
 113
 114
 115 /**********************************************************************/
 116 /***                      Line rendering                            ***/
 117 /**********************************************************************/
 118
 119
 120 #if CHAN_BITS == 8
 121
 122
 123 #define GET_XRB(XRB)  struct xmesa_renderbuffer *XRB = \
 124    xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0]->Wrapped)
 125
 126
 127 /*
 128  * Draw a flat-shaded, PF_TRUECOLOR line into an XImage.
 129  */
 130 #define NAME flat_TRUECOLOR_line
 131 #define SETUP_CODE                                      \
 132    XMesaContext xmesa = XMESA_CONTEXT(ctx);             \
 133    GET_XRB(xrb);                                        \
 134    const GLubyte *color = vert1->color;                 \
 135    unsigned long pixel;                                 \
 136    PACK_TRUECOLOR( pixel, color[0], color[1], color[2] );
 137 #define CLIP_HACK 1
 138 #define PLOT(X,Y) XMesaPutPixel(xrb->ximage, X, YFLIP(xrb, Y), pixel );
 139 #include "swrast/s_linetemp.h"
 140
 141
 142
 143 /*
 144  * Draw a flat-shaded, PF_8A8B8G8R line into an XImage.
 145  */
 146 #define NAME flat_8A8B8G8R_line
 147 #define SETUP_CODE                                              \
 148    GET_XRB(xrb);                                                \
 149    const GLubyte *color = vert1->color;                         \
 150    GLuint pixel = PACK_8A8B8G8R(color[0], color[1], color[2], color[3]);
 151 #define PIXEL_TYPE GLuint
 152 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 153 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
 154 #define CLIP_HACK 1
 155 #define PLOT(X,Y) *pixelPtr = pixel;
 156 #include "swrast/s_linetemp.h"
 157
 158
 159
 160 /*
 161  * Draw a flat-shaded, PF_8A8R8G8B line into an XImage.
 162  */
 163 #define NAME flat_8A8R8G8B_line
 164 #define SETUP_CODE                                              \
 165    GET_XRB(xrb);                                                \
 166    const GLubyte *color = vert1->color;                         \
 167    GLuint pixel = PACK_8A8R8G8B(color[0], color[1], color[2], color[3]);
 168 #define PIXEL_TYPE GLuint
 169 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 170 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
 171 #define CLIP_HACK 1
 172 #define PLOT(X,Y) *pixelPtr = pixel;
 173 #include "swrast/s_linetemp.h"
 174
 175
 176
 177 /*
 178  * Draw a flat-shaded, PF_8R8G8B line into an XImage.
 179  */
 180 #define NAME flat_8R8G8B_line
 181 #define SETUP_CODE                                              \
 182    GET_XRB(xrb);                                                \
 183    const GLubyte *color = vert1->color;                         \
 184    GLuint pixel = PACK_8R8G8B( color[0], color[1], color[2] );
 185 #define PIXEL_TYPE GLuint
 186 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 187 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
 188 #define CLIP_HACK 1
 189 #define PLOT(X,Y) *pixelPtr = pixel;
 190 #include "swrast/s_linetemp.h"
 191
 192
 193
 194 /*
 195  * Draw a flat-shaded, PF_8R8G8B24 line into an XImage.
 196  */
 197 #define NAME flat_8R8G8B24_line
 198 #define SETUP_CODE                                              \
 199    GET_XRB(xrb);                                                \
 200    const GLubyte *color = vert1->color;
 201 #define PIXEL_TYPE bgr_t
 202 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 203 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y)
 204 #define CLIP_HACK 1
 205 #define PLOT(X,Y) {                     \
 206       pixelPtr->r = color[RCOMP];       \
 207       pixelPtr->g = color[GCOMP];       \
 208       pixelPtr->b = color[BCOMP];       \
 209 }
 210 #include "swrast/s_linetemp.h"
 211
 212
 213
 214 /*
 215  * Draw a flat-shaded, PF_5R6G5B line into an XImage.
 216  */
 217 #define NAME flat_5R6G5B_line
 218 #define SETUP_CODE                                              \
 219    GET_XRB(xrb);                                                \
 220    const GLubyte *color = vert1->color;                         \
 221    GLushort pixel = PACK_5R6G5B( color[0], color[1], color[2] );
 222 #define PIXEL_TYPE GLushort
 223 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 224 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
 225 #define CLIP_HACK 1
 226 #define PLOT(X,Y) *pixelPtr = pixel;
 227 #include "swrast/s_linetemp.h"
 228
 229
 230
 231 /*
 232  * Draw a flat-shaded, PF_DITHER_5R6G5B line into an XImage.
 233  */
 234 #define NAME flat_DITHER_5R6G5B_line
 235 #define SETUP_CODE                                              \
 236    GET_XRB(xrb);                                                \
 237    XMesaContext xmesa = XMESA_CONTEXT(ctx);                     \
 238    const GLubyte *color = vert1->color;
 239 #define PIXEL_TYPE GLushort
 240 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 241 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y)
 242 #define CLIP_HACK 1
 243 #define PLOT(X,Y) PACK_TRUEDITHER( *pixelPtr, X, Y, color[0], color[1], color[2] );
 244 #include "swrast/s_linetemp.h"
 245
 246
 247
 248
 249 /*
 250  * Draw a flat-shaded, PF_DITHER 8-bit line into an XImage.
 251  */
 252 #define NAME flat_DITHER8_line
 253 #define SETUP_CODE                                              \
 254    GET_XRB(xrb);                                                \
 255    const GLubyte *color = vert1->color;                         \
 256    GLint r = color[0], g = color[1], b = color[2];              \
 257    DITHER_SETUP;
 258 #define PIXEL_TYPE GLubyte
 259 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 260 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y)
 261 #define CLIP_HACK 1
 262 #define PLOT(X,Y) *pixelPtr = DITHER(X,Y,r,g,b);
 263 #include "swrast/s_linetemp.h"
 264
 265
 266
 267 /*
 268  * Draw a flat-shaded, PF_LOOKUP 8-bit line into an XImage.
 269  */
 270 #define NAME flat_LOOKUP8_line
 271 #define SETUP_CODE                                              \
 272    GET_XRB(xrb);                                                \
 273    const GLubyte *color = vert1->color;                         \
 274    GLubyte pixel;                                               \
 275    LOOKUP_SETUP;                                                \
 276    pixel = (GLubyte) LOOKUP( color[0], color[1], color[2] );
 277 #define PIXEL_TYPE GLubyte
 278 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 279 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X,Y)
 280 #define CLIP_HACK 1
 281 #define PLOT(X,Y) *pixelPtr = pixel;
 282 #include "swrast/s_linetemp.h"
 283
 284
 285
 286 /*
 287  * Draw a flat-shaded, PF_HPCR line into an XImage.
 288  */
 289 #define NAME flat_HPCR_line
 290 #define SETUP_CODE                                              \
 291    GET_XRB(xrb);                                                \
 292    XMesaContext xmesa = XMESA_CONTEXT(ctx);                     \
 293    const GLubyte *color = vert1->color;                         \
 294    GLint r = color[0], g = color[1], b = color[2];
 295 #define PIXEL_TYPE GLubyte
 296 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 297 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X,Y)
 298 #define CLIP_HACK 1
 299 #define PLOT(X,Y) *pixelPtr = (GLubyte) DITHER_HPCR(X,Y,r,g,b);
 300 #include "swrast/s_linetemp.h"
 301
 302
 303
 304
 305 /*
 306  * Draw a flat-shaded, Z-less, PF_TRUECOLOR line into an XImage.
 307  */
 308 #define NAME flat_TRUECOLOR_z_line
 309 #define SETUP_CODE                                              \
 310    GET_XRB(xrb);                                                \
 311    XMesaContext xmesa = XMESA_CONTEXT(ctx);                     \
 312    const GLubyte *color = vert1->color;                         \
 313    unsigned long pixel;                                         \
 314    PACK_TRUECOLOR( pixel, color[0], color[1], color[2] );
 315 #define INTERP_Z 1
 316 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 317 #define CLIP_HACK 1
 318 #define PLOT(X,Y)                                                       \
 319         if (Z < *zPtr) {                                                \
 320            *zPtr = Z;                                                   \
 321            XMesaPutPixel(xrb->ximage, X, YFLIP(xrb, Y), pixel);         \
 322         }
 323 #include "swrast/s_linetemp.h"
 324
 325
 326
 327 /*
 328  * Draw a flat-shaded, Z-less, PF_8A8B8G8R line into an XImage.
 329  */
 330 #define NAME flat_8A8B8G8R_z_line
 331 #define SETUP_CODE                                              \
 332    GET_XRB(xrb);                                                \
 333    const GLubyte *color = vert1->color;                         \
 334    GLuint pixel = PACK_8A8B8G8R(color[0], color[1], color[2], color[3]);
 335 #define INTERP_Z 1
 336 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 337 #define PIXEL_TYPE GLuint
 338 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 339 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X,Y)
 340 #define CLIP_HACK 1
 341 #define PLOT(X,Y)               \
 342         if (Z < *zPtr) {        \
 343            *zPtr = Z;           \
 344            *pixelPtr = pixel;   \
 345         }
 346 #include "swrast/s_linetemp.h"
 347
 348
 349
 350 /*
 351  * Draw a flat-shaded, Z-less, PF_8A8R8G8B line into an XImage.
 352  */
 353 #define NAME flat_8A8R8G8B_z_line
 354 #define SETUP_CODE                                              \
 355    GET_XRB(xrb);                                                \
 356    const GLubyte *color = vert1->color;                         \
 357    GLuint pixel = PACK_8A8R8G8B(color[0], color[1], color[2], color[3]);
 358 #define INTERP_Z 1
 359 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 360 #define PIXEL_TYPE GLuint
 361 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 362 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X,Y)
 363 #define CLIP_HACK 1
 364 #define PLOT(X,Y)               \
 365         if (Z < *zPtr) {        \
 366            *zPtr = Z;           \
 367            *pixelPtr = pixel;   \
 368         }
 369 #include "swrast/s_linetemp.h"
 370
 371
 372
 373 /*
 374  * Draw a flat-shaded, Z-less, PF_8R8G8B line into an XImage.
 375  */
 376 #define NAME flat_8R8G8B_z_line
 377 #define SETUP_CODE                                              \
 378    GET_XRB(xrb);                                                \
 379    const GLubyte *color = vert1->color;                         \
 380    GLuint pixel = PACK_8R8G8B( color[0], color[1], color[2] );
 381 #define INTERP_Z 1
 382 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 383 #define PIXEL_TYPE GLuint
 384 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 385 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X,Y)
 386 #define CLIP_HACK 1
 387 #define PLOT(X,Y)               \
 388         if (Z < *zPtr) {        \
 389            *zPtr = Z;           \
 390            *pixelPtr = pixel;   \
 391         }
 392 #include "swrast/s_linetemp.h"
 393
 394
 395
 396 /*
 397  * Draw a flat-shaded, Z-less, PF_8R8G8B24 line into an XImage.
 398  */
 399 #define NAME flat_8R8G8B24_z_line
 400 #define SETUP_CODE                                              \
 401    GET_XRB(xrb);                                                \
 402    const GLubyte *color = vert1->color;
 403 #define INTERP_Z 1
 404 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 405 #define PIXEL_TYPE bgr_t
 406 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 407 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X,Y)
 408 #define CLIP_HACK 1
 409 #define PLOT(X,Y)                       \
 410         if (Z < *zPtr) {                \
 411            *zPtr = Z;                   \
 412            pixelPtr->r = color[RCOMP];  \
 413            pixelPtr->g = color[GCOMP];  \
 414            pixelPtr->b = color[BCOMP];  \
 415         }
 416 #include "swrast/s_linetemp.h"
 417
 418
 419
 420 /*
 421  * Draw a flat-shaded, Z-less, PF_5R6G5B line into an XImage.
 422  */
 423 #define NAME flat_5R6G5B_z_line
 424 #define SETUP_CODE                                              \
 425    GET_XRB(xrb);                                                \
 426    const GLubyte *color = vert1->color;                         \
 427    GLushort pixel = PACK_5R6G5B( color[0], color[1], color[2] );
 428 #define INTERP_Z 1
 429 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 430 #define PIXEL_TYPE GLushort
 431 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 432 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X,Y)
 433 #define CLIP_HACK 1
 434 #define PLOT(X,Y)               \
 435         if (Z < *zPtr) {        \
 436            *zPtr = Z;           \
 437            *pixelPtr = pixel;   \
 438         }
 439 #include "swrast/s_linetemp.h"
 440
 441
 442
 443 /*
 444  * Draw a flat-shaded, Z-less, PF_DITHER_5R6G5B line into an XImage.
 445  */
 446 #define NAME flat_DITHER_5R6G5B_z_line
 447 #define SETUP_CODE                                      \
 448    GET_XRB(xrb);                                                \
 449    XMesaContext xmesa = XMESA_CONTEXT(ctx);             \
 450    const GLubyte *color = vert1->color;
 451 #define INTERP_Z 1
 452 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 453 #define PIXEL_TYPE GLushort
 454 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 455 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X,Y)
 456 #define CLIP_HACK 1
 457 #define PLOT(X,Y)               \
 458         if (Z < *zPtr) {        \
 459            *zPtr = Z;           \
 460            PACK_TRUEDITHER(*pixelPtr, X, Y, color[0], color[1], color[2]); \
 461         }
 462 #include "swrast/s_linetemp.h"
 463
 464
 465
 466 /*
 467  * Draw a flat-shaded, Z-less, PF_DITHER 8-bit line into an XImage.
 468  */
 469 #define NAME flat_DITHER8_z_line
 470 #define SETUP_CODE                                      \
 471    GET_XRB(xrb);                                                \
 472    const GLubyte *color = vert1->color;                 \
 473    GLint r = color[0], g = color[1], b = color[2];      \
 474    DITHER_SETUP;
 475 #define INTERP_Z 1
 476 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 477 #define PIXEL_TYPE GLubyte
 478 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 479 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X,Y)
 480 #define CLIP_HACK 1
 481 #define PLOT(X,Y)                                               \
 482         if (Z < *zPtr) {                                        \
 483            *zPtr = Z;                                           \
 484            *pixelPtr = (GLubyte) DITHER( X, Y, r, g, b);        \
 485         }
 486 #include "swrast/s_linetemp.h"
 487
 488
 489
 490 /*
 491  * Draw a flat-shaded, Z-less, PF_LOOKUP 8-bit line into an XImage.
 492  */
 493 #define NAME flat_LOOKUP8_z_line
 494 #define SETUP_CODE                                              \
 495    GET_XRB(xrb);                                                \
 496    const GLubyte *color = vert1->color;                         \
 497    GLubyte pixel;                                               \
 498    LOOKUP_SETUP;                                                \
 499    pixel = (GLubyte) LOOKUP( color[0], color[1], color[2] );
 500 #define INTERP_Z 1
 501 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 502 #define PIXEL_TYPE GLubyte
 503 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 504 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X,Y)
 505 #define CLIP_HACK 1
 506 #define PLOT(X,Y)               \
 507         if (Z < *zPtr) {        \
 508            *zPtr = Z;           \
 509            *pixelPtr = pixel;   \
 510         }
 511 #include "swrast/s_linetemp.h"
 512
 513
 514
 515 /*
 516  * Draw a flat-shaded, Z-less, PF_HPCR line into an XImage.
 517  */
 518 #define NAME flat_HPCR_z_line
 519 #define SETUP_CODE                                              \
 520    GET_XRB(xrb);                                                \
 521    XMesaContext xmesa = XMESA_CONTEXT(ctx);                     \
 522    const GLubyte *color = vert1->color;                         \
 523    GLint r = color[0], g = color[1], b = color[2];
 524 #define INTERP_Z 1
 525 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 526 #define PIXEL_TYPE GLubyte
 527 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
 528 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X,Y)
 529 #define CLIP_HACK 1
 530 #define PLOT(X,Y)                                               \
 531         if (Z < *zPtr) {                                        \
 532            *zPtr = Z;                                           \
 533            *pixelPtr = (GLubyte) DITHER_HPCR( X, Y, r, g, b);   \
 534         }
 535 #include "swrast/s_linetemp.h"
 536
 537
 538
 539
 540 /**
 541  * Draw fast, XOR line with XDrawLine in front color buffer.
 542  * WARNING: this isn't fully OpenGL conformant because different pixels
 543  * will be hit versus using the other line functions.
 544  * Don't use the code in X server GLcore module since we need a wrapper
 545  * for the XSetLineAttributes() function call.
 546  */
 547 static void
 548 xor_line(struct gl_context *ctx, const SWvertex *vert0, const SWvertex *vert1)
 549 {
 550    XMesaContext xmesa = XMESA_CONTEXT(ctx);
 551    XMesaDisplay *dpy = xmesa->xm_visual->display;
 552    XMesaGC gc = xmesa->xm_buffer->gc;
 553    GET_XRB(xrb);
 554    unsigned long pixel = xmesa_color_to_pixel(ctx,
 555                                               vert1->color[0], vert1->color[1],
 556                                               vert1->color[2], vert1->color[3],
 557                                               xmesa->pixelformat);
 558    int x0 =            (GLint) vert0->attrib[FRAG_ATTRIB_WPOS][0];
 559    int y0 = YFLIP(xrb, (GLint) vert0->attrib[FRAG_ATTRIB_WPOS][1]);
 560    int x1 =            (GLint) vert1->attrib[FRAG_ATTRIB_WPOS][0];
 561    int y1 = YFLIP(xrb, (GLint) vert1->attrib[FRAG_ATTRIB_WPOS][1]);
 562    XMesaSetForeground(dpy, gc, pixel);
 563    XMesaSetFunction(dpy, gc, GXxor);
 564    XSetLineAttributes(dpy, gc, (int) ctx->Line.Width,
 565                       LineSolid, CapButt, JoinMiter);
 566    XDrawLine(dpy, xrb->pixmap, gc, x0, y0, x1, y1);
 567    XMesaSetFunction(dpy, gc, GXcopy);  /* this gc is used elsewhere */
 568 }
 569
 570
 571 #endif /* CHAN_BITS == 8 */
 572
 573
 574 /**
 575  * Return pointer to line drawing function, or NULL if we should use a
 576  * swrast fallback.
 577  */
 578 static swrast_line_func
 579 get_line_func(struct gl_context *ctx)
 580 {
 581 #if CHAN_BITS == 8
 582    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 583    XMesaContext xmesa = XMESA_CONTEXT(ctx);
 584    XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer);
 585    const int depth = GET_VISUAL_DEPTH(xmesa->xm_visual);
 586    const struct xmesa_renderbuffer *xrb;
 587
 588    if ((ctx->DrawBuffer->_ColorDrawBufferIndexes[0] != BUFFER_BIT_FRONT_LEFT) &&
 589        (ctx->DrawBuffer->_ColorDrawBufferIndexes[0] != BUFFER_BIT_BACK_LEFT))
 590       return (swrast_line_func) NULL;
 591    if (ctx->RenderMode != GL_RENDER)      return (swrast_line_func) NULL;
 592    if (ctx->Line.SmoothFlag)              return (swrast_line_func) NULL;
 593    if (ctx->Texture._EnabledUnits)        return (swrast_line_func) NULL;
 594    if (ctx->Light.ShadeModel != GL_FLAT)  return (swrast_line_func) NULL;
 595    if (ctx->Line.StippleFlag)             return (swrast_line_func) NULL;
 596    if (swrast->_RasterMask & MULTI_DRAW_BIT) return (swrast_line_func) NULL;
 597    if (xmbuf->swAlpha)                    return (swrast_line_func) NULL;
 598
 599    xrb = xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0]->Wrapped);
 600
 601    if (xrb->ximage
 602        && swrast->_RasterMask==DEPTH_BIT
 603        && ctx->Depth.Func==GL_LESS
 604        && ctx->Depth.Mask==GL_TRUE
 605        && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
 606        && ctx->Line.Width==1.0F) {
 607       switch (xmesa->pixelformat) {
 608          case PF_Truecolor:
 609             return flat_TRUECOLOR_z_line;
 610          case PF_8A8B8G8R:
 611             return flat_8A8B8G8R_z_line;
 612          case PF_8A8R8G8B:
 613             return flat_8A8R8G8B_z_line;
 614          case PF_8R8G8B:
 615             return flat_8R8G8B_z_line;
 616          case PF_8R8G8B24:
 617             return flat_8R8G8B24_z_line;
 618          case PF_5R6G5B:
 619             return flat_5R6G5B_z_line;
 620          case PF_Dither_5R6G5B:
 621             return flat_DITHER_5R6G5B_z_line;
 622          case PF_Dither:
 623             return (depth==8) ? flat_DITHER8_z_line : (swrast_line_func) NULL;
 624          case PF_Lookup:
 625             return (depth==8) ? flat_LOOKUP8_z_line : (swrast_line_func) NULL;
 626          case PF_HPCR:
 627             return flat_HPCR_z_line;
 628          default:
 629             return (swrast_line_func)NULL;
 630       }
 631    }
 632    if (xrb->ximage
 633        && swrast->_RasterMask==0
 634        && ctx->Line.Width==1.0F) {
 635       switch (xmesa->pixelformat) {
 636          case PF_Truecolor:
 637             return flat_TRUECOLOR_line;
 638          case PF_8A8B8G8R:
 639             return flat_8A8B8G8R_line;
 640          case PF_8A8R8G8B:
 641             return flat_8A8R8G8B_line;
 642          case PF_8R8G8B:
 643             return flat_8R8G8B_line;
 644          case PF_8R8G8B24:
 645             return flat_8R8G8B24_line;
 646          case PF_5R6G5B:
 647             return flat_5R6G5B_line;
 648          case PF_Dither_5R6G5B:
 649             return flat_DITHER_5R6G5B_line;
 650          case PF_Dither:
 651             return (depth==8) ? flat_DITHER8_line : (swrast_line_func) NULL;
 652          case PF_Lookup:
 653             return (depth==8) ? flat_LOOKUP8_line : (swrast_line_func) NULL;
 654          case PF_HPCR:
 655             return flat_HPCR_line;
 656          default:
 657             return (swrast_line_func)NULL;
 658       }
 659    }
 660
 661    if (ctx->DrawBuffer->_NumColorDrawBuffers == 1
 662        && ctx->DrawBuffer->_ColorDrawBufferIndexes[0] == BUFFER_FRONT_LEFT
 663        && swrast->_RasterMask == LOGIC_OP_BIT
 664        && ctx->Color.LogicOp == GL_XOR
 665        && !ctx->Line.StippleFlag
 666        && !ctx->Line.SmoothFlag) {
 667       return xor_line;
 668    }
 669
 670 #endif /* CHAN_BITS == 8 */
 671    return (swrast_line_func) NULL;
 672 }
 673
 674
 675 /**
 676  * Override for the swrast line-selection function.  Try to use one
 677  * of our internal line functions, otherwise fall back to the
 678  * standard swrast functions.
 679  */
 680 void
 681 xmesa_choose_line(struct gl_context *ctx)
 682 {
 683    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 684
 685    if (!(swrast->Line = get_line_func( ctx )))
 686       _swrast_choose_line( ctx );
 687 }