xm_line.c

Mesa is an open-source implementation of the OpenGL specification - a system for rendering interacti

/*
 * 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 (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_8R8G8B line into an XImage.
 */
#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 (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_8R8G8B24 line into an XImage.
 */
#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 (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) {		\
	   *zPtr = Z;			\
           pixelPtr->r = color[RCOMP];	\
           pixelPtr->g = color[GCOMP];	\
           pixelPtr->b = color[BCOMP];	\
	}
#include "swrast/s_linetemp.h"



/*
 * Draw a flat-shaded, Z-less, PF_5R6G5B line into an XImage.
 */
#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 (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 "swrast/s_linetemp.h"



/*
 * Draw a flat-shaded, Z-less, PF_DITHER_5R6G5B line into an XImage.
 */
#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 (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 "swrast/s_linetemp.h"



/*
 * Draw a flat-shaded, Z-less, PF_DITHER 8-bit line into an XImage.
 */
#define NAME flat_DITHER8_z_line
#define SETUP_CODE					\
   GET_XRB(xrb);						\
   const GLubyte *color = vert1->color;			\
   GLint r = color[0], g = color[1], b = color[2];	\
   DITHER_SETUP;
#define INTERP_Z 1
#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
#define PIXEL_TYPE GLubyte
#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X,Y)
#define CLIP_HACK 1
#define PLOT(X,Y)						\
	if (Z < *zPtr) {					\
	   *zPtr = Z;						\
	   *pixelPtr = (GLubyte) DITHER( X, Y, r, g, b);	\
	}
#include "swrast/s_linetemp.h"



/*
 * Draw a flat-shaded, Z-less, PF_LOOKUP 8-bit line into an XImage.
 */
#define NAME flat_LOOKUP8_z_line
#define SETUP_CODE						\
   GET_XRB(xrb);						\
   const GLubyte *color = vert1->color;				\
   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 (xrb->ximage->bytes_per_line)
#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(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_HPCR line into an XImage.
 */
#define NAME flat_HPCR_z_line
#define SETUP_CODE 						\
   GET_XRB(xrb);						\
   XMesaContext xmesa = XMESA_CONTEXT(ctx);			\
   const GLubyte *color = vert1->color;				\
   GLint r = color[0], g = color[1], b = color[2];
#define INTERP_Z 1
#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
#define PIXEL_TYPE GLubyte
#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, 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 "swrast/s_linetemp.h"




#ifndef XFree86Server
/**
 * 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
xor_line(GLcontext *ctx, const SWvertex *vert0, const SWvertex *vert1)
{
   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[FRAG_ATTRIB_WPOS][0];
   int y0 = YFLIP(xrb, (GLint) vert0->attrib[FRAG_ATTRIB_WPOS][1]);
   int x1 =            (GLint) vert1->attrib[FRAG_ATTRIB_WPOS][0];
   int y1 = YFLIP(xrb, (GLint) vert1->attrib[FRAG_ATTRIB_WPOS][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 */
}
#endif /* XFree86Server */


#endif /* CHAN_BITS == 8 */


/**
 * Return pointer to line drawing function, or NULL if we should use a
 * swrast fallback.
 */
static swrast_line_func
get_line_func(GLcontext *ctx)
{
#if CHAN_BITS == 8
   SWcontext *swrast = SWRAST_CONTEXT(ctx);
   XMesaContext xmesa = XMESA_CONTEXT(ctx);
   XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer);
   const int depth = GET_VISUAL_DEPTH(xmesa->xm_visual);
   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;
   if (xmbuf->swAlpha)                    return (swrast_line_func) NULL;

   xrb = xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0]->Wrapped);

   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->Line.Width==1.0F) {
      switch (xmesa->pixelformat) {
         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:
            return flat_DITHER_5R6G5B_z_line;
         case PF_Dither:
            return (depth==8) ? flat_DITHER8_z_line : (swrast_line_func) NULL;
         case PF_Lookup:
            return (depth==8) ? flat_LOOKUP8_z_line : (swrast_line_func) NULL;
         case PF_HPCR:
            return flat_HPCR_z_line;
         default:
            return (swrast_line_func)NULL;
      }
   }
   if (xrb->ximage
       && swrast->_RasterMask==0
       && ctx->Line.Width==1.0F) {
      switch (xmesa->pixelformat) {
         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:
            return flat_DITHER_5R6G5B_line;
         case PF_Dither:
            return (depth==8) ? flat_DITHER8_line : (swrast_line_func) NULL;
         case PF_Lookup:
            return (depth==8) ? flat_LOOKUP8_line : (swrast_line_func) NULL;
         case PF_HPCR:
            return flat_HPCR_line;
	 default:
	    return (swrast_line_func)NULL;
      }
   }

#ifndef XFree86Server
   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 /* XFree86Server */

#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(GLcontext *ctx)
{
   SWcontext *swrast = SWRAST_CONTEXT(ctx);

   if (!(swrast->Line = get_line_func( ctx )))
      _swrast_choose_line( ctx );
}