path: root/src/mesa/drivers/glide/fxddspan.c

/*
 * Mesa 3-D graphics library
 * Version:  3.3
 *
 * Copyright (C) 1999-2000  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.
 *
 *
 * Original Mesa / 3Dfx device driver (C) 1999 David Bucciarelli, by the
 * terms stated above.
 *
 * Thank you for your contribution, David!
 *
 * Please make note of the above copyright/license statement.  If you
 * contributed code or bug fixes to this code under the previous (GNU
 * Library) license and object to the new license, your code will be
 * removed at your request.  Please see the Mesa docs/COPYRIGHT file
 * for more information.
 *
 * Additional Mesa/3Dfx driver developers:
 *   Daryll Strauss <daryll@precisioninsight.com>
 *   Keith Whitwell <keith@precisioninsight.com>
 *
 * See fxapi.h for more revision/author details.
 */


/* fxdd.c - 3Dfx VooDoo Mesa span and pixel functions */


#ifdef HAVE_CONFIG_H
#include "conf.h"
#endif

#if defined(FX)

#include "fxdrv.h"

#ifdef _MSC_VER
#ifdef _WIN32
#pragma warning( disable : 4090 4022 )
/* 4101 : "different 'const' qualifier"
 * 4022 : "pointer mistmatch for actual parameter 'n'
 */
#endif
#endif


#if !defined(FXMESA_USE_ARGB)



#define writeRegionClipped(fxm,dst_buffer,dst_x,dst_y,src_format,src_width,src_height,src_stride,src_data)		\
  FX_grLfbWriteRegion(dst_buffer,dst_x,dst_y,src_format,src_width,src_height,src_stride,src_data)



/* KW: Rearranged the args in the call to grLfbWriteRegion().
 */
#define LFB_WRITE_SPAN_MESA(dst_buffer,		\
			    dst_x,		\
			    dst_y,		\
			    src_width,		\
			    src_stride,		\
			    src_data)		\
  writeRegionClipped(fxMesa, dst_buffer,	\
		   dst_x,			\
		   dst_y,			\
		   GR_LFB_SRC_FMT_8888,		\
		   src_width,			\
		   1,				\
		   src_stride,			\
		   src_data)			\


#else /* !defined(FXMESA_USE_RGBA) */

#define writeRegionClipped(fxm,dst_buffer,dst_x,dst_y,src_format,src_width,src_height,src_stride,src_data)		\
  FX_grLfbWriteRegion(dst_buffer,dst_x,dst_y,src_format,src_width,src_height,src_stride,src_data)


#define MESACOLOR_TO_ARGB(c) (				\
             ( ((unsigned int)(c[ACOMP]))<<24 ) |	\
             ( ((unsigned int)(c[RCOMP]))<<16 ) |	\
             ( ((unsigned int)(c[GCOMP]))<<8 )  |	\
             (  (unsigned int)(c[BCOMP])) )

inline void
LFB_WRITE_SPAN_MESA(GrBuffer_t dst_buffer,
		    FxU32 dst_x,
		    FxU32 dst_y,
		    FxU32 src_width, FxI32 src_stride, void *src_data)
{
   /* Covert to ARGB */
   GLubyte(*rgba)[4] = src_data;
   GLuint argb[MAX_WIDTH];
   int i;

   for (i = 0; i < src_width; i++) {
      argb[i] = MESACOLOR_TO_ARGB(rgba[i]);
   }
   writeRegionClipped( /*fxMesa, */ NULL, dst_buffer,
		      dst_x,
		      dst_y,
		      GR_LFB_SRC_FMT_8888,
		      src_width, 1, src_stride, (void *) argb);
}

#endif /* !defined(FXMESA_USE_RGBA) */


/************************************************************************/
/*****                    Span functions                            *****/
/************************************************************************/


static void
fxDDWriteRGBASpan(const GLcontext * ctx,
		  GLuint n, GLint x, GLint y,
		  const GLubyte rgba[][4], const GLubyte mask[])
{
   fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx;
   GLuint i;
   GLint bottom = fxMesa->height - 1;

   if (MESA_VERBOSE & VERBOSE_DRIVER) {
      fprintf(stderr, "fxmesa: fxDDWriteRGBASpan(...)\n");
   }

   if (mask) {
      int span = 0;

      for (i = 0; i < n; i++) {
	 if (mask[i]) {
	    ++span;
	 }
	 else {
	    if (span > 0) {
	       LFB_WRITE_SPAN_MESA(fxMesa->currentFB, x + i - span,
				   bottom - y,
				   /* GR_LFB_SRC_FMT_8888, */ span, /*1, */ 0,
				   (void *) rgba[i - span]);
	       span = 0;
	    }
	 }
      }

      if (span > 0)
	 LFB_WRITE_SPAN_MESA(fxMesa->currentFB, x + n - span, bottom - y,
			     /* GR_LFB_SRC_FMT_8888, */ span, /*1, */ 0,
			     (void *) rgba[n - span]);
   }
   else
      LFB_WRITE_SPAN_MESA(fxMesa->currentFB, x, bottom - y,	/* GR_LFB_SRC_FMT_8888, */
			  n, /* 1, */ 0, (void *) rgba);
}


static void
fxDDWriteRGBSpan(const GLcontext * ctx,
		 GLuint n, GLint x, GLint y,
		 const GLubyte rgb[][3], const GLubyte mask[])
{
   fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx;
   GLuint i;
   GLint bottom = fxMesa->height - 1;
   GLubyte rgba[MAX_WIDTH][4];

   if (MESA_VERBOSE & VERBOSE_DRIVER) {
      fprintf(stderr, "fxmesa: fxDDWriteRGBSpan()\n");
   }

   if (mask) {
      int span = 0;

      for (i = 0; i < n; i++) {
	 if (mask[i]) {
	    rgba[span][RCOMP] = rgb[i][0];
	    rgba[span][GCOMP] = rgb[i][1];
	    rgba[span][BCOMP] = rgb[i][2];
	    rgba[span][ACOMP] = 255;
	    ++span;
	 }
	 else {
	    if (span > 0) {
	       LFB_WRITE_SPAN_MESA(fxMesa->currentFB, x + i - span,
				   bottom - y,
				   /*GR_LFB_SRC_FMT_8888, */ span, /* 1, */ 0,
				   (void *) rgba);
	       span = 0;
	    }
	 }
      }

      if (span > 0)
	 LFB_WRITE_SPAN_MESA(fxMesa->currentFB, x + n - span, bottom - y,
			     /*GR_LFB_SRC_FMT_8888, */ span, /* 1, */ 0,
			     (void *) rgba);
   }
   else {
      for (i = 0; i < n; i++) {
	 rgba[i][RCOMP] = rgb[i][0];
	 rgba[i][GCOMP] = rgb[i][1];
	 rgba[i][BCOMP] = rgb[i][2];
	 rgba[i][ACOMP] = 255;
      }

      LFB_WRITE_SPAN_MESA(fxMesa->currentFB, x, bottom - y,	/* GR_LFB_SRC_FMT_8888, */
			  n, /* 1, */ 0, (void *) rgba);
   }
}


static void
fxDDWriteMonoRGBASpan(const GLcontext * ctx,
		      GLuint n, GLint x, GLint y,
		      const GLchan color[4], const GLubyte mask[])
{
   fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx;
   GLuint i;
   GLint bottom = fxMesa->height - 1;
   GLuint data[MAX_WIDTH];
   GrColor_t gColor = FXCOLOR4(color);

   if (MESA_VERBOSE & VERBOSE_DRIVER) {
      fprintf(stderr, "fxmesa: fxDDWriteMonoRGBASpan(...)\n");
   }

   if (mask) {
      int span = 0;

      for (i = 0; i < n; i++) {
	 if (mask[i]) {
	    data[span] = (GLuint) gColor;
	    ++span;
	 }
	 else {
	    if (span > 0) {
	       writeRegionClipped(fxMesa, fxMesa->currentFB, x + i - span,
				  bottom - y, GR_LFB_SRC_FMT_8888, span, 1, 0,
				  (void *) data);
	       span = 0;
	    }
	 }
      }

      if (span > 0)
	 writeRegionClipped(fxMesa, fxMesa->currentFB, x + n - span,
			    bottom - y, GR_LFB_SRC_FMT_8888, span, 1, 0,
			    (void *) data);
   }
   else {
      for (i = 0; i < n; i++) {
	 data[i] = (GLuint) gColor;
      }

      writeRegionClipped(fxMesa, fxMesa->currentFB, x, bottom - y,
			 GR_LFB_SRC_FMT_8888, n, 1, 0, (void *) data);
   }
}


#if 0
static void
fxDDReadRGBASpan(const GLcontext * ctx,
		 GLuint n, GLint x, GLint y, GLubyte rgba[][4])
{
   fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx;
   GLushort data[MAX_WIDTH];
   GLuint i;
   GLint bottom = fxMesa->height - 1;

   printf("read span %d, %d, %d\n", x, y, n);
   if (MESA_VERBOSE & VERBOSE_DRIVER) {
      fprintf(stderr, "fxmesa: fxDDReadRGBASpan(...)\n");
   }

   assert(n < MAX_WIDTH);

   FX_grLfbReadRegion(fxMesa->currentFB, x, bottom - y, n, 1, 0, data);

   for (i = 0; i < n; i++) {
      GLushort pixel = data[i];
      rgba[i][RCOMP] = FX_PixelToR[pixel];
      rgba[i][GCOMP] = FX_PixelToG[pixel];
      rgba[i][BCOMP] = FX_PixelToB[pixel];
      rgba[i][ACOMP] = 255;
   }
}
#endif


/*
 * Read a span of 16-bit RGB pixels.  Note, we don't worry about cliprects
 * since OpenGL says obscured pixels have undefined values.
 */
static void
read_R5G6B5_span(const GLcontext * ctx,
		 GLuint n, GLint x, GLint y, GLubyte rgba[][4])
{
   fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx;
   GrLfbInfo_t info;
   BEGIN_BOARD_LOCK();
   if (grLfbLock(GR_LFB_READ_ONLY,
		 fxMesa->currentFB,
		 GR_LFBWRITEMODE_ANY, GR_ORIGIN_UPPER_LEFT, FXFALSE, &info)) {
      const GLint winX = 0;
      const GLint winY = fxMesa->height - 1;
      const GLint srcStride = info.strideInBytes / 2;	/* stride in GLushorts */
      const GLushort *data16 = (const GLushort *) info.lfbPtr
	 + (winY - y) * srcStride + (winX + x);
      const GLuint *data32 = (const GLuint *) data16;
      GLuint i, j;
      GLuint extraPixel = (n & 1);
      n -= extraPixel;
      for (i = j = 0; i < n; i += 2, j++) {
	 GLuint pixel = data32[j];
	 GLuint pixel0 = pixel & 0xffff;
	 GLuint pixel1 = pixel >> 16;
	 rgba[i][RCOMP] = FX_PixelToR[pixel0];
	 rgba[i][GCOMP] = FX_PixelToG[pixel0];
	 rgba[i][BCOMP] = FX_PixelToB[pixel0];
	 rgba[i][ACOMP] = 255;
	 rgba[i + 1][RCOMP] = FX_PixelToR[pixel1];
	 rgba[i + 1][GCOMP] = FX_PixelToG[pixel1];
	 rgba[i + 1][BCOMP] = FX_PixelToB[pixel1];
	 rgba[i + 1][ACOMP] = 255;
      }
      if (extraPixel) {
	 GLushort pixel = data16[n];
	 rgba[n][RCOMP] = FX_PixelToR[pixel];
	 rgba[n][GCOMP] = FX_PixelToG[pixel];
	 rgba[n][BCOMP] = FX_PixelToB[pixel];
	 rgba[n][ACOMP] = 255;
      }

      grLfbUnlock(GR_LFB_READ_ONLY, fxMesa->currentFB);
   }
   END_BOARD_LOCK();
}


/************************************************************************/
/*****                    Pixel functions                           *****/
/************************************************************************/

static void
fxDDWriteRGBAPixels(const GLcontext * ctx,
		    GLuint n, const GLint x[], const GLint y[],
		    CONST GLubyte rgba[][4], const GLubyte mask[])
{
   fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx;
   GLuint i;
   GLint bottom = fxMesa->height - 1;

   if (MESA_VERBOSE & VERBOSE_DRIVER) {
      fprintf(stderr, "fxmesa: fxDDWriteRGBAPixels(...)\n");
   }

   for (i = 0; i < n; i++)
      if (mask[i])
	 LFB_WRITE_SPAN_MESA(fxMesa->currentFB, x[i], bottom - y[i],
			     1, 1, (void *) rgba[i]);
}

static void
fxDDWriteMonoRGBAPixels(const GLcontext * ctx,
			GLuint n, const GLint x[], const GLint y[],
			const GLchan color[4], const GLubyte mask[])
{
   fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx;
   GLuint i;
   GLint bottom = fxMesa->height - 1;
   GrColor_t gColor = FXCOLOR4(color);

   if (MESA_VERBOSE & VERBOSE_DRIVER) {
      fprintf(stderr, "fxmesa: fxDDWriteMonoRGBAPixels(...)\n");
   }

   for (i = 0; i < n; i++)
      if (mask[i])
	 writeRegionClipped(fxMesa, fxMesa->currentFB, x[i], bottom - y[i],
			    GR_LFB_SRC_FMT_8888, 1, 1, 0, (void *) &gColor);
}


static void
read_R5G6B5_pixels(const GLcontext * ctx,
		   GLuint n, const GLint x[], const GLint y[],
		   GLubyte rgba[][4], const GLubyte mask[])
{
   fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx;
   GrLfbInfo_t info;
   BEGIN_BOARD_LOCK();
   if (grLfbLock(GR_LFB_READ_ONLY,
		 fxMesa->currentFB,
		 GR_LFBWRITEMODE_ANY, GR_ORIGIN_UPPER_LEFT, FXFALSE, &info)) {
      const GLint srcStride = info.strideInBytes / 2;	/* stride in GLushorts */
      const GLint winX = 0;
      const GLint winY = fxMesa->height - 1;
      GLuint i;
      for (i = 0; i < n; i++) {
	 if (mask[i]) {
	    const GLushort *data16 = (const GLushort *) info.lfbPtr
	       + (winY - y[i]) * srcStride + (winX + x[i]);
	    const GLushort pixel = *data16;
	    rgba[i][RCOMP] = FX_PixelToR[pixel];
	    rgba[i][GCOMP] = FX_PixelToG[pixel];
	    rgba[i][BCOMP] = FX_PixelToB[pixel];
	    rgba[i][ACOMP] = 255;
	 }
      }
      grLfbUnlock(GR_LFB_READ_ONLY, fxMesa->currentFB);
   }
   END_BOARD_LOCK();
}



/************************************************************************/
/*****                    Depth functions                           *****/
/************************************************************************/

void
fxDDWriteDepthSpan(GLcontext * ctx,
		   GLuint n, GLint x, GLint y, const GLdepth depth[],
		   const GLubyte mask[])
{
   fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx;
   GLint bottom = fxMesa->height - 1;

   if (MESA_VERBOSE & VERBOSE_DRIVER) {
      fprintf(stderr, "fxmesa: fxDDWriteDepthSpan(...)\n");
   }


   if (mask) {
      GLint i;
      for (i = 0; i < n; i++) {
	 if (mask[i]) {
	    GLshort d = depth[i];
	    writeRegionClipped(fxMesa, GR_BUFFER_AUXBUFFER, x + i, bottom - y,
			       GR_LFB_SRC_FMT_ZA16, 1, 1, 0, (void *) &d);
	 }
      }
   }
   else {
      GLushort depth16[MAX_WIDTH];
      GLint i;
      for (i = 0; i < n; i++) {
	 depth16[i] = depth[i];
      }
      writeRegionClipped(fxMesa, GR_BUFFER_AUXBUFFER, x, bottom - y,
			 GR_LFB_SRC_FMT_ZA16, n, 1, 0, (void *) depth16);
   }
}


void
fxDDReadDepthSpan(GLcontext * ctx,
		  GLuint n, GLint x, GLint y, GLdepth depth[])
{
   fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx;
   GLint bottom = fxMesa->height - 1;
   GLushort depth16[MAX_WIDTH];
   GLuint i;

   if (MESA_VERBOSE & VERBOSE_DRIVER) {
      fprintf(stderr, "fxmesa: fxDDReadDepthSpan(...)\n");
   }

   FX_grLfbReadRegion(GR_BUFFER_AUXBUFFER, x, bottom - y, n, 1, 0, depth16);
   for (i = 0; i < n; i++) {
      depth[i] = depth16[i];
   }
}



void
fxDDWriteDepthPixels(GLcontext * ctx,
		     GLuint n, const GLint x[], const GLint y[],
		     const GLdepth depth[], const GLubyte mask[])
{
   fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx;
   GLint bottom = fxMesa->height - 1;
   GLuint i;

   if (MESA_VERBOSE & VERBOSE_DRIVER) {
      fprintf(stderr, "fxmesa: fxDDWriteDepthPixels(...)\n");
   }

   for (i = 0; i < n; i++) {
      if (mask[i]) {
	 int xpos = x[i];
	 int ypos = bottom - y[i];
	 GLushort d = depth[i];
	 writeRegionClipped(fxMesa, GR_BUFFER_AUXBUFFER, xpos, ypos,
			    GR_LFB_SRC_FMT_ZA16, 1, 1, 0, (void *) &d);
      }
   }
}


void
fxDDReadDepthPixels(GLcontext * ctx, GLuint n,
		    const GLint x[], const GLint y[], GLdepth depth[])
{
   fxMesaContext fxMesa = (fxMesaContext) ctx->DriverCtx;
   GLint bottom = fxMesa->height - 1;
   GLuint i;

   if (MESA_VERBOSE & VERBOSE_DRIVER) {
      fprintf(stderr, "fxmesa: fxDDReadDepthPixels(...)\n");
   }

   for (i = 0; i < n; i++) {
      int xpos = x[i];
      int ypos = bottom - y[i];
      GLushort d;
      FX_grLfbReadRegion(GR_BUFFER_AUXBUFFER, xpos, ypos, 1, 1, 0, &d);
      depth[i] = d;
   }
}




/************************************************************************/


void
fxSetupDDSpanPointers(GLcontext * ctx)
{
   ctx->Driver.WriteRGBASpan = fxDDWriteRGBASpan;
   ctx->Driver.WriteRGBSpan = fxDDWriteRGBSpan;
   ctx->Driver.WriteMonoRGBASpan = fxDDWriteMonoRGBASpan;
   ctx->Driver.WriteRGBAPixels = fxDDWriteRGBAPixels;
   ctx->Driver.WriteMonoRGBAPixels = fxDDWriteMonoRGBAPixels;

   ctx->Driver.WriteCI8Span = NULL;
   ctx->Driver.WriteCI32Span = NULL;
   ctx->Driver.WriteMonoCISpan = NULL;
   ctx->Driver.WriteCI32Pixels = NULL;
   ctx->Driver.WriteMonoCIPixels = NULL;

   /*  ctx->Driver.ReadRGBASpan        =fxDDReadRGBASpan; */
   ctx->Driver.ReadRGBASpan = read_R5G6B5_span;
   ctx->Driver.ReadRGBAPixels = read_R5G6B5_pixels;

   ctx->Driver.ReadCI32Span = NULL;
   ctx->Driver.ReadCI32Pixels = NULL;
}


#else


/*
 * Need this to provide at least one external definition.
 */

extern int gl_fx_dummy_function_span(void);
int
gl_fx_dummy_function_span(void)
{
   return 0;
}

#endif /* FX */