X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fdrivers%2Fx11%2Fxm_line.c;h=00307c71f72ffb15c3cf16050ad5ec7d2ea20e02;hb=02128c448d1f4eedf70b3bdb4ec187cf405c530e;hp=7a51948212558fe64510d206d224268cb4359e9d;hpb=eb6c6439ae23e47b79b72f3737b6d0d14e1f9f26;p=mesa.git diff --git a/src/mesa/drivers/x11/xm_line.c b/src/mesa/drivers/x11/xm_line.c index 7a519482125..00307c71f72 100644 --- a/src/mesa/drivers/x11/xm_line.c +++ b/src/mesa/drivers/x11/xm_line.c @@ -1,27 +1,25 @@ -/* $Id: xm_line.c,v 1.4 2000/09/28 22:44:32 brianp Exp $ */ - /* * Mesa 3-D graphics library - * Version: 3.5 - * - * Copyright (C) 1999-2000 Brian Paul All Rights Reserved. - * + * + * Copyright (C) 1999-2006 Brian Paul All Rights Reserved. + * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. - * + * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN - * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. */ @@ -33,12 +31,16 @@ #include "glxheader.h" -#include "depth.h" -#include "macros.h" -#include "vb.h" -#include "types.h" +#include "main/macros.h" +#include "main/mtypes.h" #include "xmesaP.h" +/* Internal swrast includes: + */ +#include "swrast/s_depth.h" +#include "swrast/s_points.h" +#include "swrast/s_lines.h" +#include "swrast/s_context.h" /**********************************************************************/ @@ -49,66 +51,62 @@ /* * Render an array of points into a pixmap, any pixel format. */ -static void draw_points_ANY_pixmap( GLcontext *ctx, GLuint first, GLuint last ) +#if 000 +/* XXX don't use this, it doesn't dither correctly */ +static void draw_points_ANY_pixmap( struct gl_context *ctx, const SWvertex *vert ) { - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; + XMesaContext xmesa = XMESA_CONTEXT(ctx); XMesaDisplay *dpy = xmesa->xm_visual->display; XMesaDrawable buffer = xmesa->xm_buffer->buffer; - XMesaGC gc = xmesa->xm_buffer->gc2; - struct vertex_buffer *VB = ctx->VB; - register GLuint i; - - if (xmesa->xm_visual->gl_visual->RGBAflag) { - /* RGB mode */ - for (i=first;i<=last;i++) { - if (VB->ClipMask[i]==0) { - register int x, y; - const GLubyte *color = VB->ColorPtr->data[i]; - unsigned long pixel = xmesa_color_to_pixel( xmesa, - color[0], color[1], color[2], color[3], xmesa->pixelformat); - XMesaSetForeground( dpy, gc, pixel ); - x = (GLint) VB->Win.data[i][0]; - y = FLIP( xmesa->xm_buffer, (GLint) VB->Win.data[i][1] ); - XMesaDrawPoint( dpy, buffer, gc, x, y); - } - } + XMesaGC gc = xmesa->xm_buffer->gc; + + if (xmesa->xm_visual->mesa_visual.RGBAflag) { + register int x, y; + const GLubyte *color = vert->color; + unsigned long pixel = xmesa_color_to_pixel( xmesa, + color[0], color[1], + color[2], color[3], + xmesa->pixelformat); + XMesaSetForeground( dpy, gc, pixel ); + x = (GLint) vert->win[0]; + y = YFLIP( xrb, (GLint) vert->win[1] ); + XMesaDrawPoint( dpy, buffer, gc, x, y); } else { /* Color index mode */ - for (i=first;i<=last;i++) { - if (VB->ClipMask[i]==0) { - register int x, y; - XMesaSetForeground( dpy, gc, VB->IndexPtr->data[i] ); - x = (GLint) VB->Win.data[i][0]; - y = FLIP( xmesa->xm_buffer, (GLint) VB->Win.data[i][1] ); - XMesaDrawPoint( dpy, buffer, gc, x, y); - } - } + register int x, y; + XMesaSetForeground( dpy, gc, vert->index ); + x = (GLint) vert->win[0]; + y = YFLIP( xrb, (GLint) vert->win[1] ); + XMesaDrawPoint( dpy, buffer, gc, x, y); } } +#endif - -/* - * Analyze context state to see if we can provide a fast points drawing - * function, like those in points.c. Otherwise, return NULL. +/* Override the swrast point-selection function. Try to use one of + * our internal point functions, otherwise fall back to the standard + * swrast functions. */ -points_func xmesa_get_points_func( GLcontext *ctx ) +void xmesa_choose_point( struct gl_context *ctx ) { - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - - if (ctx->Point.Size==1.0F && !ctx->Point.SmoothFlag && ctx->RasterMask==0 - && !ctx->Texture.ReallyEnabled) { - if (xmesa->xm_buffer->buffer==XIMAGE) { - return (points_func) NULL; /*draw_points_ximage;*/ - } - else { - return draw_points_ANY_pixmap; - } +#if 0 + XMesaContext xmesa = XMESA_CONTEXT(ctx); + SWcontext *swrast = SWRAST_CONTEXT(ctx); + + if (ctx->RenderMode == GL_RENDER + && ctx->Point.Size == 1.0F && !ctx->Point.SmoothFlag + && swrast->_RasterMask == 0 + && !ctx->Texture._EnabledUnits + && xmesa->xm_buffer->buffer != XIMAGE) { + swrast->Point = draw_points_ANY_pixmap; } else { - return (points_func) NULL; + _swrast_choose_point( ctx ); } +#else + _swrast_choose_point( ctx ); +#endif } @@ -118,321 +116,237 @@ points_func xmesa_get_points_func( GLcontext *ctx ) /**********************************************************************/ -#if 0 -/* - * Render a line into a pixmap, any pixel format. - */ -static void flat_pixmap_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - struct vertex_buffer *VB = ctx->VB; - register int x0, y0, x1, y1; - XMesaGC gc; - unsigned long pixel; - if (xmesa->xm_visual->gl_visual->RGBAflag) { - const GLubyte *color = VB->ColorPtr->data[pv]; - pixel = xmesa_color_to_pixel( xmesa, color[0], color[1], color[2], color[3], - xmesa->pixelformat ); - } - else { - pixel = VB->IndexPtr->data[pv]; - } - gc = xmesa->xm_buffer->gc2; - XMesaSetForeground( xmesa->display, gc, pixel ); - - x0 = (GLint) VB->Win.data[vert0][0]; - y0 = FLIP( xmesa->xm_buffer, (GLint) VB->Win.data[vert0][1] ); - x1 = (GLint) VB->Win.data[vert1][0]; - y1 = FLIP( xmesa->xm_buffer, (GLint) VB->Win.data[vert1][1] ); - XMesaDrawLine( xmesa->display, xmesa->xm_buffer->buffer, gc, - x0, y0, x1, y1 ); -} -#endif +#if CHAN_BITS == 8 + + +#define GET_XRB(XRB) struct xmesa_renderbuffer *XRB = \ + xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0]) /* * Draw a flat-shaded, PF_TRUECOLOR line into an XImage. */ -static void flat_TRUECOLOR_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - const GLubyte *color = ctx->VB->ColorPtr->data[pv]; - XMesaImage *img = xmesa->xm_buffer->backimage; - unsigned long pixel; +#define NAME flat_TRUECOLOR_line +#define SETUP_CODE \ + XMesaContext xmesa = XMESA_CONTEXT(ctx); \ + GET_XRB(xrb); \ + const GLubyte *color = vert1->color; \ + unsigned long pixel; \ PACK_TRUECOLOR( pixel, color[0], color[1], color[2] ); - -#define INTERP_XY 1 #define CLIP_HACK 1 -#define PLOT(X,Y) XMesaPutPixel( img, X, FLIP(xmesa->xm_buffer, Y), pixel ); - -#include "linetemp.h" -} +#define PLOT(X,Y) XMesaPutPixel(xrb->ximage, X, YFLIP(xrb, Y), pixel ); +#include "swrast/s_linetemp.h" /* * Draw a flat-shaded, PF_8A8B8G8R line into an XImage. */ -static void flat_8A8B8G8R_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - const GLubyte *color = ctx->VB->ColorPtr->data[pv]; - GLuint pixel = PACK_8B8G8R( color[0], color[1], color[2] ); +#define NAME flat_8A8B8G8R_line +#define SETUP_CODE \ + GET_XRB(xrb); \ + const GLubyte *color = vert1->color; \ + GLuint pixel = PACK_8A8B8G8R(color[0], color[1], color[2], color[3]); +#define PIXEL_TYPE GLuint +#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) +#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) +#define CLIP_HACK 1 +#define PLOT(X,Y) *pixelPtr = pixel; +#include "swrast/s_linetemp.h" + + +/* + * Draw a flat-shaded, PF_8A8R8G8B line into an XImage. + */ +#define NAME flat_8A8R8G8B_line +#define SETUP_CODE \ + GET_XRB(xrb); \ + const GLubyte *color = vert1->color; \ + GLuint pixel = PACK_8A8R8G8B(color[0], color[1], color[2], color[3]); #define PIXEL_TYPE GLuint -#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line) -#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y) +#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) +#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) #define CLIP_HACK 1 #define PLOT(X,Y) *pixelPtr = pixel; +#include "swrast/s_linetemp.h" -#include "linetemp.h" -} /* * Draw a flat-shaded, PF_8R8G8B line into an XImage. */ -static void flat_8R8G8B_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - const GLubyte *color = ctx->VB->ColorPtr->data[pv]; +#define NAME flat_8R8G8B_line +#define SETUP_CODE \ + GET_XRB(xrb); \ + const GLubyte *color = vert1->color; \ GLuint pixel = PACK_8R8G8B( color[0], color[1], color[2] ); - #define PIXEL_TYPE GLuint -#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line) -#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y) +#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) +#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) #define CLIP_HACK 1 #define PLOT(X,Y) *pixelPtr = pixel; +#include "swrast/s_linetemp.h" -#include "linetemp.h" -} /* * Draw a flat-shaded, PF_8R8G8B24 line into an XImage. */ -static void flat_8R8G8B24_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - const GLubyte *color = ctx->VB->ColorPtr->data[pv]; - +#define NAME flat_8R8G8B24_line +#define SETUP_CODE \ + GET_XRB(xrb); \ + const GLubyte *color = vert1->color; #define PIXEL_TYPE bgr_t -#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line) -#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y) +#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) +#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y) #define CLIP_HACK 1 #define PLOT(X,Y) { \ pixelPtr->r = color[RCOMP]; \ pixelPtr->g = color[GCOMP]; \ pixelPtr->b = color[BCOMP]; \ } +#include "swrast/s_linetemp.h" -#include "linetemp.h" -} /* * Draw a flat-shaded, PF_5R6G5B line into an XImage. */ -static void flat_5R6G5B_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - const GLubyte *color = ctx->VB->ColorPtr->data[pv]; +#define NAME flat_5R6G5B_line +#define SETUP_CODE \ + GET_XRB(xrb); \ + const GLubyte *color = vert1->color; \ GLushort pixel = PACK_5R6G5B( color[0], color[1], color[2] ); - #define PIXEL_TYPE GLushort -#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line) -#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y) +#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) +#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y) #define CLIP_HACK 1 #define PLOT(X,Y) *pixelPtr = pixel; +#include "swrast/s_linetemp.h" -#include "linetemp.h" -} /* * Draw a flat-shaded, PF_DITHER_5R6G5B line into an XImage. */ -static void flat_DITHER_5R6G5B_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - const GLubyte *color = ctx->VB->ColorPtr->data[pv]; - +#define NAME flat_DITHER_5R6G5B_line +#define SETUP_CODE \ + GET_XRB(xrb); \ + XMesaContext xmesa = XMESA_CONTEXT(ctx); \ + const GLubyte *color = vert1->color; #define PIXEL_TYPE GLushort -#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line) -#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y) +#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) +#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y) #define CLIP_HACK 1 #define PLOT(X,Y) PACK_TRUEDITHER( *pixelPtr, X, Y, color[0], color[1], color[2] ); - -#include "linetemp.h" -} - - - -/* - * Draw a flat-shaded, PF_DITHER 8-bit line into an XImage. - */ -static void flat_DITHER8_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - const GLubyte *color = ctx->VB->ColorPtr->data[pv]; - GLint r = color[0], g = color[1], b = color[2]; - DITHER_SETUP; - -#define INTERP_XY 1 -#define PIXEL_TYPE GLubyte -#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line) -#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y) -#define CLIP_HACK 1 -#define PLOT(X,Y) *pixelPtr = DITHER(X,Y,r,g,b); - -#include "linetemp.h" -} - - -/* - * Draw a flat-shaded, PF_LOOKUP 8-bit line into an XImage. - */ -static void flat_LOOKUP8_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - const GLubyte *color = ctx->VB->ColorPtr->data[pv]; - GLubyte pixel; - LOOKUP_SETUP; - pixel = (GLubyte) LOOKUP( color[0], color[1], color[2] ); - -#define PIXEL_TYPE GLubyte -#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line) -#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y) -#define CLIP_HACK 1 -#define PLOT(X,Y) *pixelPtr = pixel; - -#include "linetemp.h" -} - - -/* - * Draw a flat-shaded, PF_HPCR line into an XImage. - */ -static void flat_HPCR_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - const GLubyte *color = ctx->VB->ColorPtr->data[pv]; - GLint r = color[0], g = color[1], b = color[2]; - -#define INTERP_XY 1 -#define PIXEL_TYPE GLubyte -#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line) -#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y) -#define CLIP_HACK 1 -#define PLOT(X,Y) *pixelPtr = (GLubyte) DITHER_HPCR(X,Y,r,g,b); - -#include "linetemp.h" -} +#include "swrast/s_linetemp.h" /* * Draw a flat-shaded, Z-less, PF_TRUECOLOR line into an XImage. */ -static void flat_TRUECOLOR_z_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - const GLubyte *color = ctx->VB->ColorPtr->data[pv]; - XMesaImage *img = xmesa->xm_buffer->backimage; - unsigned long pixel; +#define NAME flat_TRUECOLOR_z_line +#define SETUP_CODE \ + GET_XRB(xrb); \ + XMesaContext xmesa = XMESA_CONTEXT(ctx); \ + const GLubyte *color = vert1->color; \ + unsigned long pixel; \ PACK_TRUECOLOR( pixel, color[0], color[1], color[2] ); - -#define INTERP_XY 1 #define INTERP_Z 1 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE #define CLIP_HACK 1 #define PLOT(X,Y) \ if (Z < *zPtr) { \ *zPtr = Z; \ - XMesaPutPixel( img, X, FLIP(xmesa->xm_buffer, Y), pixel ); \ + XMesaPutPixel(xrb->ximage, X, YFLIP(xrb, Y), pixel); \ } +#include "swrast/s_linetemp.h" -#include "linetemp.h" -} /* * Draw a flat-shaded, Z-less, PF_8A8B8G8R line into an XImage. */ -static void flat_8A8B8G8R_z_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - const GLubyte *color = ctx->VB->ColorPtr->data[pv]; - GLuint pixel = PACK_8B8G8R( color[0], color[1], color[2] ); +#define NAME flat_8A8B8G8R_z_line +#define SETUP_CODE \ + GET_XRB(xrb); \ + const GLubyte *color = vert1->color; \ + GLuint pixel = PACK_8A8B8G8R(color[0], color[1], color[2], color[3]); +#define INTERP_Z 1 +#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE +#define PIXEL_TYPE GLuint +#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) +#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X,Y) +#define CLIP_HACK 1 +#define PLOT(X,Y) \ + if (Z < *zPtr) { \ + *zPtr = Z; \ + *pixelPtr = pixel; \ + } +#include "swrast/s_linetemp.h" + + +/* + * Draw a flat-shaded, Z-less, PF_8A8R8G8B line into an XImage. + */ +#define NAME flat_8A8R8G8B_z_line +#define SETUP_CODE \ + GET_XRB(xrb); \ + const GLubyte *color = vert1->color; \ + GLuint pixel = PACK_8A8R8G8B(color[0], color[1], color[2], color[3]); #define INTERP_Z 1 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE #define PIXEL_TYPE GLuint -#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line) -#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y) +#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) +#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X,Y) #define CLIP_HACK 1 #define PLOT(X,Y) \ if (Z < *zPtr) { \ *zPtr = Z; \ *pixelPtr = pixel; \ } +#include "swrast/s_linetemp.h" -#include "linetemp.h" -} /* * Draw a flat-shaded, Z-less, PF_8R8G8B line into an XImage. */ -static void flat_8R8G8B_z_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - const GLubyte *color = ctx->VB->ColorPtr->data[pv]; +#define NAME flat_8R8G8B_z_line +#define SETUP_CODE \ + GET_XRB(xrb); \ + const GLubyte *color = vert1->color; \ GLuint pixel = PACK_8R8G8B( color[0], color[1], color[2] ); - #define INTERP_Z 1 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE #define PIXEL_TYPE GLuint -#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line) -#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y) +#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) +#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X,Y) #define CLIP_HACK 1 #define PLOT(X,Y) \ if (Z < *zPtr) { \ *zPtr = Z; \ *pixelPtr = pixel; \ } +#include "swrast/s_linetemp.h" -#include "linetemp.h" -} /* * Draw a flat-shaded, Z-less, PF_8R8G8B24 line into an XImage. */ -static void flat_8R8G8B24_z_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - const GLubyte *color = ctx->VB->ColorPtr->data[pv]; - +#define NAME flat_8R8G8B24_z_line +#define SETUP_CODE \ + GET_XRB(xrb); \ + const GLubyte *color = vert1->color; #define INTERP_Z 1 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE #define PIXEL_TYPE bgr_t -#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line) -#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y) +#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) +#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X,Y) #define CLIP_HACK 1 #define PLOT(X,Y) \ if (Z < *zPtr) { \ @@ -441,308 +355,186 @@ static void flat_8R8G8B24_z_line( GLcontext *ctx, pixelPtr->g = color[GCOMP]; \ pixelPtr->b = color[BCOMP]; \ } +#include "swrast/s_linetemp.h" -#include "linetemp.h" -} /* * Draw a flat-shaded, Z-less, PF_5R6G5B line into an XImage. */ -static void flat_5R6G5B_z_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - const GLubyte *color = ctx->VB->ColorPtr->data[pv]; +#define NAME flat_5R6G5B_z_line +#define SETUP_CODE \ + GET_XRB(xrb); \ + const GLubyte *color = vert1->color; \ GLushort pixel = PACK_5R6G5B( color[0], color[1], color[2] ); - #define INTERP_Z 1 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE #define PIXEL_TYPE GLushort -#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line) -#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y) +#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) +#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X,Y) #define CLIP_HACK 1 #define PLOT(X,Y) \ if (Z < *zPtr) { \ *zPtr = Z; \ *pixelPtr = pixel; \ } -#include "linetemp.h" -} +#include "swrast/s_linetemp.h" + /* * Draw a flat-shaded, Z-less, PF_DITHER_5R6G5B line into an XImage. */ -static void flat_DITHER_5R6G5B_z_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - const GLubyte *color = ctx->VB->ColorPtr->data[pv]; - +#define NAME flat_DITHER_5R6G5B_z_line +#define SETUP_CODE \ + GET_XRB(xrb); \ + XMesaContext xmesa = XMESA_CONTEXT(ctx); \ + const GLubyte *color = vert1->color; #define INTERP_Z 1 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE #define PIXEL_TYPE GLushort -#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line) -#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y) +#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) +#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X,Y) #define CLIP_HACK 1 #define PLOT(X,Y) \ if (Z < *zPtr) { \ *zPtr = Z; \ PACK_TRUEDITHER(*pixelPtr, X, Y, color[0], color[1], color[2]); \ } -#include "linetemp.h" -} - - -/* - * Draw a flat-shaded, Z-less, PF_DITHER 8-bit line into an XImage. - */ -static void flat_DITHER8_z_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - const GLubyte *color = ctx->VB->ColorPtr->data[pv]; - GLint r = color[0], g = color[1], b = color[2]; - DITHER_SETUP; +#include "swrast/s_linetemp.h" -#define INTERP_XY 1 -#define INTERP_Z 1 -#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE -#define PIXEL_TYPE GLubyte -#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line) -#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y) -#define CLIP_HACK 1 -#define PLOT(X,Y) \ - if (Z < *zPtr) { \ - *zPtr = Z; \ - *pixelPtr = (GLubyte) DITHER( X, Y, r, g, b); \ - } -#include "linetemp.h" -} -/* - * Draw a flat-shaded, Z-less, PF_LOOKUP 8-bit line into an XImage. +/** + * Draw fast, XOR line with XDrawLine in front color buffer. + * WARNING: this isn't fully OpenGL conformant because different pixels + * will be hit versus using the other line functions. + * Don't use the code in X server GLcore module since we need a wrapper + * for the XSetLineAttributes() function call. */ -static void flat_LOOKUP8_z_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) +static void +xor_line(struct gl_context *ctx, const SWvertex *vert0, const SWvertex *vert1) { - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - const GLubyte *color = ctx->VB->ColorPtr->data[pv]; - GLubyte pixel; - LOOKUP_SETUP; - pixel = (GLubyte) LOOKUP( color[0], color[1], color[2] ); - -#define INTERP_Z 1 -#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE -#define PIXEL_TYPE GLubyte -#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line) -#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y) -#define CLIP_HACK 1 -#define PLOT(X,Y) \ - if (Z < *zPtr) { \ - *zPtr = Z; \ - *pixelPtr = pixel; \ - } - -#include "linetemp.h" -} - - -/* - * Draw a flat-shaded, Z-less, PF_HPCR line into an XImage. - */ -static void flat_HPCR_z_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pv ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - const GLubyte *color = ctx->VB->ColorPtr->data[pv]; - GLint r = color[0], g = color[1], b = color[2]; - -#define INTERP_XY 1 -#define INTERP_Z 1 -#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE -#define PIXEL_TYPE GLubyte -#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line) -#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y) -#define CLIP_HACK 1 -#define PLOT(X,Y) \ - if (Z < *zPtr) { \ - *zPtr = Z; \ - *pixelPtr = (GLubyte) DITHER_HPCR( X, Y, r, g, b); \ - } - -#include "linetemp.h" + XMesaContext xmesa = XMESA_CONTEXT(ctx); + XMesaDisplay *dpy = xmesa->xm_visual->display; + XMesaGC gc = xmesa->xm_buffer->gc; + GET_XRB(xrb); + unsigned long pixel = xmesa_color_to_pixel(ctx, + vert1->color[0], vert1->color[1], + vert1->color[2], vert1->color[3], + xmesa->pixelformat); + int x0 = (GLint) vert0->attrib[VARYING_SLOT_POS][0]; + int y0 = YFLIP(xrb, (GLint) vert0->attrib[VARYING_SLOT_POS][1]); + int x1 = (GLint) vert1->attrib[VARYING_SLOT_POS][0]; + int y1 = YFLIP(xrb, (GLint) vert1->attrib[VARYING_SLOT_POS][1]); + XMesaSetForeground(dpy, gc, pixel); + XMesaSetFunction(dpy, gc, GXxor); + XSetLineAttributes(dpy, gc, (int) ctx->Line.Width, + LineSolid, CapButt, JoinMiter); + XDrawLine(dpy, xrb->pixmap, gc, x0, y0, x1, y1); + XMesaSetFunction(dpy, gc, GXcopy); /* this gc is used elsewhere */ } -#if 0 -/* - * Examine ctx->Line attributes and set xmesa->xm_buffer->gc1 - * and xmesa->xm_buffer->gc2 appropriately. - */ -static void setup_x_line_options( GLcontext *ctx ) -{ - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - int i, state, state0, new_state, len, offs; - int tbit; - char *dptr; - int n_segments = 0; - char dashes[20]; - int line_width, line_style; - - /*** Line Stipple ***/ - if (ctx->Line.StippleFlag) { - const int pattern = ctx->Line.StipplePattern; - - dptr = dashes; - state0 = state = ((pattern & 1) != 0); - - /* Decompose the pattern */ - for (i=1,tbit=2,len=1;i<16;++i,tbit=(tbit<<1)) - { - new_state = ((tbit & pattern) != 0); - if (state != new_state) - { - *dptr++ = ctx->Line.StippleFactor * len; - len = 1; - state = new_state; - } - else - ++len; - } - *dptr = ctx->Line.StippleFactor * len; - n_segments = 1 + (dptr - dashes); - - /* ensure an even no. of segments, or X may toggle on/off for consecutive patterns */ - /* if (n_segments & 1) dashes [n_segments++] = 0; value of 0 not allowed in dash list */ - - /* Handle case where line style starts OFF */ - if (state0 == 0) - offs = dashes[0]; - else - offs = 0; +#endif /* CHAN_BITS == 8 */ -#if 0 -fprintf (stderr, "input pattern: 0x%04x, offset %d, %d segments:", pattern, offs, n_segments); -for (i = 0; i < n_segments; i++) -fprintf (stderr, " %d", dashes[i]); -fprintf (stderr, "\n"); -#endif - - XMesaSetDashes( xmesa->display, xmesa->xm_buffer->gc1, - offs, dashes, n_segments ); - XMesaSetDashes( xmesa->display, xmesa->xm_buffer->gc2, - offs, dashes, n_segments ); - - line_style = LineOnOffDash; - } - else { - line_style = LineSolid; - } - /*** Line Width ***/ - line_width = (int) (ctx->Line.Width+0.5F); - if (line_width < 2) { - /* Use fast lines when possible */ - line_width = 0; - } - - /*** Set GC attributes ***/ - XMesaSetLineAttributes( xmesa->display, xmesa->xm_buffer->gc1, - line_width, line_style, CapButt, JoinBevel); - XMesaSetLineAttributes( xmesa->display, xmesa->xm_buffer->gc2, - line_width, line_style, CapButt, JoinBevel); - XMesaSetFillStyle( xmesa->display, xmesa->xm_buffer->gc1, FillSolid ); - XMesaSetFillStyle( xmesa->display, xmesa->xm_buffer->gc2, FillSolid ); -} -#endif - - - -/* - * Analyze context state to see if we can provide a fast line drawing - * function, like those in lines.c. Otherwise, return NULL. +/** + * Return pointer to line drawing function, or NULL if we should use a + * swrast fallback. */ -line_func xmesa_get_line_func( GLcontext *ctx ) +static swrast_line_func +get_line_func(struct gl_context *ctx) { - XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; - int depth = GET_VISUAL_DEPTH(xmesa->xm_visual); - - (void) DitherValues; /* silence unused var warning */ - (void) kernel1; /* silence unused var warning */ - - if (ctx->Line.SmoothFlag) return (line_func)NULL; - if (ctx->Texture.ReallyEnabled) return (line_func)NULL; - if (ctx->Light.ShadeModel!=GL_FLAT) return (line_func)NULL; - /* X line stippling doesn't match OpenGL stippling */ - if (ctx->Line.StippleFlag==GL_TRUE) return (line_func)NULL; - - if (xmesa->xm_buffer->buffer==XIMAGE - && ctx->RasterMask==DEPTH_BIT +#if CHAN_BITS == 8 + SWcontext *swrast = SWRAST_CONTEXT(ctx); + XMesaContext xmesa = XMESA_CONTEXT(ctx); + const struct xmesa_renderbuffer *xrb; + + if ((ctx->DrawBuffer->_ColorDrawBufferIndexes[0] != BUFFER_BIT_FRONT_LEFT) && + (ctx->DrawBuffer->_ColorDrawBufferIndexes[0] != BUFFER_BIT_BACK_LEFT)) + return (swrast_line_func) NULL; + if (ctx->RenderMode != GL_RENDER) return (swrast_line_func) NULL; + if (ctx->Line.SmoothFlag) return (swrast_line_func) NULL; + if (ctx->Texture._EnabledUnits) return (swrast_line_func) NULL; + if (ctx->Light.ShadeModel != GL_FLAT) return (swrast_line_func) NULL; + if (ctx->Line.StippleFlag) return (swrast_line_func) NULL; + if (swrast->_RasterMask & MULTI_DRAW_BIT) return (swrast_line_func) NULL; + + xrb = xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0]); + + if (xrb->ximage + && swrast->_RasterMask==DEPTH_BIT && ctx->Depth.Func==GL_LESS && ctx->Depth.Mask==GL_TRUE - && ctx->Visual.DepthBits == DEFAULT_SOFTWARE_DEPTH_BITS + && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS && ctx->Line.Width==1.0F) { switch (xmesa->pixelformat) { - case PF_TRUECOLOR: + case PF_Truecolor: return flat_TRUECOLOR_z_line; case PF_8A8B8G8R: return flat_8A8B8G8R_z_line; + case PF_8A8R8G8B: + return flat_8A8R8G8B_z_line; case PF_8R8G8B: return flat_8R8G8B_z_line; case PF_8R8G8B24: return flat_8R8G8B24_z_line; case PF_5R6G5B: return flat_5R6G5B_z_line; - case PF_DITHER_5R6G5B: + case PF_Dither_5R6G5B: return flat_DITHER_5R6G5B_z_line; - case PF_DITHER: - return (depth==8) ? flat_DITHER8_z_line : (line_func)NULL; - case PF_LOOKUP: - return (depth==8) ? flat_LOOKUP8_z_line : (line_func)NULL; - case PF_HPCR: - return flat_HPCR_z_line; default: - return (line_func)NULL; + return (swrast_line_func)NULL; } } - if (xmesa->xm_buffer->buffer==XIMAGE - && ctx->RasterMask==0 + if (xrb->ximage + && swrast->_RasterMask==0 && ctx->Line.Width==1.0F) { switch (xmesa->pixelformat) { - case PF_TRUECOLOR: + case PF_Truecolor: return flat_TRUECOLOR_line; case PF_8A8B8G8R: return flat_8A8B8G8R_line; + case PF_8A8R8G8B: + return flat_8A8R8G8B_line; case PF_8R8G8B: return flat_8R8G8B_line; case PF_8R8G8B24: return flat_8R8G8B24_line; case PF_5R6G5B: return flat_5R6G5B_line; - case PF_DITHER_5R6G5B: + case PF_Dither_5R6G5B: return flat_DITHER_5R6G5B_line; - case PF_DITHER: - return (depth==8) ? flat_DITHER8_line : (line_func)NULL; - case PF_LOOKUP: - return (depth==8) ? flat_LOOKUP8_line : (line_func)NULL; - case PF_HPCR: - return flat_HPCR_line; default: - return (line_func)NULL; + return (swrast_line_func)NULL; } } -#if 0 - /* XXX have to disable this because X's rasterization rules don't match - * software Mesa's. This causes the linehv.c conformance test to fail. - * In the future, we might provide a config option to enable this. - */ - if (xmesa->xm_buffer->buffer!=XIMAGE && ctx->RasterMask==0) { - setup_x_line_options( ctx ); - return flat_pixmap_line; + + if (ctx->DrawBuffer->_NumColorDrawBuffers == 1 + && ctx->DrawBuffer->_ColorDrawBufferIndexes[0] == BUFFER_FRONT_LEFT + && swrast->_RasterMask == LOGIC_OP_BIT + && ctx->Color.LogicOp == GL_XOR + && !ctx->Line.StippleFlag + && !ctx->Line.SmoothFlag) { + return xor_line; } -#endif - return (line_func)NULL; + +#endif /* CHAN_BITS == 8 */ + return (swrast_line_func) NULL; +} + + +/** + * Override for the swrast line-selection function. Try to use one + * of our internal line functions, otherwise fall back to the + * standard swrast functions. + */ +void +xmesa_choose_line(struct gl_context *ctx) +{ + SWcontext *swrast = SWRAST_CONTEXT(ctx); + + if (!(swrast->Line = get_line_func( ctx ))) + _swrast_choose_line( ctx ); }