X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fswrast%2Fs_buffers.c;h=af475ad8cb59915a4492f60de0750761110a699b;hb=88f3656ea7ae57d22141225db0c5d90ceab420dd;hp=6c7b447aba8185686ea5e6bab5a38115cfd8033a;hpb=4753d60dd070bb08d0116076bcc08025c86ce857;p=mesa.git

diff --git a/src/mesa/swrast/s_buffers.c b/src/mesa/swrast/s_buffers.c
index 6c7b447aba8..af475ad8cb5 100644
--- a/src/mesa/swrast/s_buffers.c
+++ b/src/mesa/swrast/s_buffers.c
@@ -1,10 +1,8 @@
-/* $Id: s_buffers.c,v 1.11 2002/06/15 02:38:17 brianp Exp $ */
-
 /*
  * Mesa 3-D graphics library
- * Version:  4.1
+ * Version:  7.1
  *
- * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2008  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"),
@@ -24,237 +22,328 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
+/** XXX This file should be named s_clear.c */
 
-#include "glheader.h"
-#include "macros.h"
-#include "mem.h"
+#include "main/glheader.h"
+#include "main/colormac.h"
+#include "main/macros.h"
+#include "main/imports.h"
+#include "main/mtypes.h"
 
 #include "s_accum.h"
-#include "s_alphabuf.h"
 #include "s_context.h"
 #include "s_depth.h"
 #include "s_masking.h"
 #include "s_stencil.h"
 
 
-
-
-/*
- * Clear the color buffer when glColorMask or glIndexMask is in effect.
+/**
+ * Clear the color buffer when glColorMask is in effect.
  */
 static void
-clear_color_buffer_with_masking( GLcontext *ctx )
+clear_rgba_buffer_with_masking(GLcontext *ctx, struct gl_renderbuffer *rb)
 {
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
    const GLint x = ctx->DrawBuffer->_Xmin;
    const GLint y = ctx->DrawBuffer->_Ymin;
    const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
    const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
+   SWspan span;
+   GLint i;
 
-   if (ctx->Visual.rgbMode) {
-      /* RGBA mode */
-      const GLchan r = ctx->Color.ClearColor[0];
-      const GLchan g = ctx->Color.ClearColor[1];
-      const GLchan b = ctx->Color.ClearColor[2];
-      const GLchan a = ctx->Color.ClearColor[3];
-      GLint i;
-      for (i = 0; i < height; i++) {
-         GLchan rgba[MAX_WIDTH][4];
-         GLint j;
-         for (j = 0; j < width; j++) {
-            rgba[j][RCOMP] = r;
-            rgba[j][GCOMP] = g;
-            rgba[j][BCOMP] = b;
-            rgba[j][ACOMP] = a;
-         }
-         _mesa_mask_rgba_array( ctx, width, x, y + i, rgba );
-         (*swrast->Driver.WriteRGBASpan)( ctx, width, x, y + i,
-				       (CONST GLchan (*)[4]) rgba, NULL );
+   ASSERT(ctx->Visual.rgbMode);
+   ASSERT(rb->PutRow);
+
+   /* Initialize color span with clear color */
+   /* XXX optimize for clearcolor == black/zero (bzero) */
+   INIT_SPAN(span, GL_BITMAP);
+   span.end = width;
+   span.arrayMask = SPAN_RGBA;
+   span.array->ChanType = rb->DataType;
+   if (span.array->ChanType == GL_UNSIGNED_BYTE) {
+      GLubyte clearColor[4];
+      UNCLAMPED_FLOAT_TO_UBYTE(clearColor[RCOMP], ctx->Color.ClearColor[0]);
+      UNCLAMPED_FLOAT_TO_UBYTE(clearColor[GCOMP], ctx->Color.ClearColor[1]);
+      UNCLAMPED_FLOAT_TO_UBYTE(clearColor[BCOMP], ctx->Color.ClearColor[2]);
+      UNCLAMPED_FLOAT_TO_UBYTE(clearColor[ACOMP], ctx->Color.ClearColor[3]);
+      for (i = 0; i < width; i++) {
+         COPY_4UBV(span.array->rgba[i], clearColor);
+      }
+   }
+   else if (span.array->ChanType == GL_UNSIGNED_SHORT) {
+      GLushort clearColor[4];
+      UNCLAMPED_FLOAT_TO_USHORT(clearColor[RCOMP], ctx->Color.ClearColor[0]);
+      UNCLAMPED_FLOAT_TO_USHORT(clearColor[GCOMP], ctx->Color.ClearColor[1]);
+      UNCLAMPED_FLOAT_TO_USHORT(clearColor[BCOMP], ctx->Color.ClearColor[2]);
+      UNCLAMPED_FLOAT_TO_USHORT(clearColor[ACOMP], ctx->Color.ClearColor[3]);
+      for (i = 0; i < width; i++) {
+         COPY_4V(span.array->rgba[i], clearColor);
       }
    }
    else {
-      /* Color index mode */
-      GLuint span[MAX_WIDTH];
-      GLubyte mask[MAX_WIDTH];
-      GLint i, j;
-      MEMSET( mask, 1, width );
-      for (i=0;i<height;i++) {
-         for (j=0;j<width;j++) {
-            span[j] = ctx->Color.ClearIndex;
-         }
-         _mesa_mask_index_array( ctx, width, x, y + i, span );
-         (*swrast->Driver.WriteCI32Span)( ctx, width, x, y + i, span, mask );
+      ASSERT(span.array->ChanType == GL_FLOAT);
+      for (i = 0; i < width; i++) {
+         CLAMPED_FLOAT_TO_CHAN(span.array->rgba[i][0], ctx->Color.ClearColor[0]);
+         CLAMPED_FLOAT_TO_CHAN(span.array->rgba[i][1], ctx->Color.ClearColor[1]);
+         CLAMPED_FLOAT_TO_CHAN(span.array->rgba[i][2], ctx->Color.ClearColor[2]);
+         CLAMPED_FLOAT_TO_CHAN(span.array->rgba[i][3], ctx->Color.ClearColor[3]);
       }
    }
+
+   /* Note that masking will change the color values, but only the
+    * channels for which the write mask is GL_FALSE.  The channels
+    * which which are write-enabled won't get modified.
+    */
+   for (i = 0; i < height; i++) {
+      span.x = x;
+      span.y = y + i;
+      _swrast_mask_rgba_span(ctx, rb, &span);
+      /* write masked row */
+      rb->PutRow(ctx, rb, width, x, y + i, span.array->rgba, NULL);
+   }
 }
 
 
+/**
+ * Clear color index buffer with masking.
+ */
+static void
+clear_ci_buffer_with_masking(GLcontext *ctx, struct gl_renderbuffer *rb)
+{
+   const GLint x = ctx->DrawBuffer->_Xmin;
+   const GLint y = ctx->DrawBuffer->_Ymin;
+   const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
+   const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
+   SWspan span;
+   GLint i;
+
+   ASSERT(!ctx->Visual.rgbMode);
+   ASSERT(rb->PutRow);
+   ASSERT(rb->DataType == GL_UNSIGNED_INT);
 
-/*
- * Clear a color buffer without index/channel masking.
+   /* Initialize index span with clear index */
+   INIT_SPAN(span, GL_BITMAP);
+   span.end = width;
+   span.arrayMask = SPAN_INDEX;
+   for (i = 0; i < width;i++) {
+      span.array->index[i] = ctx->Color.ClearIndex;
+   }
+
+   /* Note that masking will change the color indexes, but only the
+    * bits for which the write mask is GL_FALSE.  The bits
+    * which are write-enabled won't get modified.
+    */
+   for (i = 0; i < height;i++) {
+      span.x = x;
+      span.y = y + i;
+      _swrast_mask_ci_span(ctx, rb, &span);
+      /* write masked row */
+      rb->PutRow(ctx, rb, width, x, y + i, span.array->index, NULL);
+   }
+}
+
+
+/**
+ * Clear an rgba color buffer without channel masking.
  */
 static void
-clear_color_buffer(GLcontext *ctx)
+clear_rgba_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
 {
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
    const GLint x = ctx->DrawBuffer->_Xmin;
    const GLint y = ctx->DrawBuffer->_Ymin;
    const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
    const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
+   GLubyte clear8[4];
+   GLushort clear16[4];
+   GLvoid *clearVal;
+   GLint i;
 
-   if (ctx->Visual.rgbMode) {
-      /* RGBA mode */
-      const GLchan r = ctx->Color.ClearColor[0];
-      const GLchan g = ctx->Color.ClearColor[1];
-      const GLchan b = ctx->Color.ClearColor[2];
-      const GLchan a = ctx->Color.ClearColor[3];
-      GLchan span[MAX_WIDTH][4];
-      GLint i;
+   ASSERT(ctx->Visual.rgbMode);
 
-      ASSERT(*((GLuint *) &ctx->Color.ColorMask) == 0xffffffff);
+   ASSERT(ctx->Color.ColorMask[0] &&
+          ctx->Color.ColorMask[1] &&
+          ctx->Color.ColorMask[2] &&
+          ctx->Color.ColorMask[3]);             
 
-      for (i = 0; i < width; i++) {
-         span[i][RCOMP] = r;
-         span[i][GCOMP] = g;
-         span[i][BCOMP] = b;
-         span[i][ACOMP] = a;
-      }
-      for (i = 0; i < height; i++) {
-         (*swrast->Driver.WriteRGBASpan)( ctx, width, x, y + i,
-                                       (CONST GLchan (*)[4]) span, NULL );
-      }
+   ASSERT(rb->PutMonoRow);
+
+   switch (rb->DataType) {
+      case GL_UNSIGNED_BYTE:
+         UNCLAMPED_FLOAT_TO_UBYTE(clear8[0], ctx->Color.ClearColor[0]);
+         UNCLAMPED_FLOAT_TO_UBYTE(clear8[1], ctx->Color.ClearColor[1]);
+         UNCLAMPED_FLOAT_TO_UBYTE(clear8[2], ctx->Color.ClearColor[2]);
+         UNCLAMPED_FLOAT_TO_UBYTE(clear8[3], ctx->Color.ClearColor[3]);
+         clearVal = clear8;
+         break;
+      case GL_UNSIGNED_SHORT:
+         UNCLAMPED_FLOAT_TO_USHORT(clear16[0], ctx->Color.ClearColor[0]);
+         UNCLAMPED_FLOAT_TO_USHORT(clear16[1], ctx->Color.ClearColor[1]);
+         UNCLAMPED_FLOAT_TO_USHORT(clear16[2], ctx->Color.ClearColor[2]);
+         UNCLAMPED_FLOAT_TO_USHORT(clear16[3], ctx->Color.ClearColor[3]);
+         clearVal = clear16;
+         break;
+      case GL_FLOAT:
+         clearVal = ctx->Color.ClearColor;
+         break;
+      default:
+         _mesa_problem(ctx, "Bad rb DataType in clear_color_buffer");
+         return;
    }
-   else {
-      /* Color index mode */
-      ASSERT((ctx->Color.IndexMask & ((1 << ctx->Visual.indexBits) - 1))
-             == (GLuint) ((1 << ctx->Visual.indexBits) - 1));
-      if (ctx->Visual.indexBits == 8) {
-         /* 8-bit clear */
-         GLubyte span[MAX_WIDTH];
-         GLint i;
-         MEMSET(span, ctx->Color.ClearIndex, width);
-         for (i = 0; i < height; i++) {
-            (*swrast->Driver.WriteCI8Span)( ctx, width, x, y + i, span, NULL );
-         }
-      }
-      else {
-         /* non 8-bit clear */
-         GLuint span[MAX_WIDTH];
-         GLint i;
-         for (i = 0; i < width; i++) {
-            span[i] = ctx->Color.ClearIndex;
-         }
-         for (i = 0; i < height; i++) {
-            (*swrast->Driver.WriteCI32Span)( ctx, width, x, y + i, span, NULL );
-         }
-      }
+
+   for (i = 0; i < height; i++) {
+      rb->PutMonoRow(ctx, rb, width, x, y + i, clearVal, NULL);
    }
 }
 
 
+/**
+ * Clear color index buffer without masking.
+ */
+static void
+clear_ci_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
+{
+   const GLint x = ctx->DrawBuffer->_Xmin;
+   const GLint y = ctx->DrawBuffer->_Ymin;
+   const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
+   const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
+   GLubyte clear8;
+   GLushort clear16;
+   GLuint clear32;
+   GLvoid *clearVal;
+   GLint i;
+
+   ASSERT(!ctx->Visual.rgbMode);
+
+   ASSERT((ctx->Color.IndexMask & ((1 << rb->IndexBits) - 1))
+          == (GLuint) ((1 << rb->IndexBits) - 1));
 
-/*
- * Clear the front/back/left/right color buffers.
- * This function is usually only called if we need to clear the
- * buffers with masking.
+   ASSERT(rb->PutMonoRow);
+
+   /* setup clear value */
+   switch (rb->DataType) {
+      case GL_UNSIGNED_BYTE:
+         clear8 = (GLubyte) ctx->Color.ClearIndex;
+         clearVal = &clear8;
+         break;
+      case GL_UNSIGNED_SHORT:
+         clear16 = (GLushort) ctx->Color.ClearIndex;
+         clearVal = &clear16;
+         break;
+      case GL_UNSIGNED_INT:
+         clear32 = ctx->Color.ClearIndex;
+         clearVal = &clear32;
+         break;
+      default:
+         _mesa_problem(ctx, "Bad rb DataType in clear_color_buffer");
+         return;
+   }
+
+   for (i = 0; i < height; i++)
+      rb->PutMonoRow(ctx, rb, width, x, y + i, clearVal, NULL);
+}
+
+
+/**
+ * Clear the front/back/left/right/aux color buffers.
+ * This function is usually only called if the device driver can't
+ * clear its own color buffers for some reason (such as with masking).
  */
 static void
 clear_color_buffers(GLcontext *ctx)
 {
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   const GLuint colorMask = *((GLuint *) &ctx->Color.ColorMask);
-   GLuint bufferBit;
-
-   /* loop over four possible dest color buffers */
-   for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
-      if (bufferBit & ctx->Color.DrawDestMask) {
-         if (bufferBit == FRONT_LEFT_BIT) {
-            (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_LEFT);
-            (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, GL_FRONT_LEFT);
-         }
-         else if (bufferBit == FRONT_RIGHT_BIT) {
-            (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_RIGHT);
-            (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, GL_FRONT_RIGHT);
-         }
-         else if (bufferBit == BACK_LEFT_BIT) {
-            (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_LEFT);
-            (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, GL_BACK_LEFT);
+   GLboolean masking;
+   GLuint buf;
+
+   if (ctx->Visual.rgbMode) {
+      if (ctx->Color.ColorMask[0] && 
+          ctx->Color.ColorMask[1] && 
+          ctx->Color.ColorMask[2] && 
+          ctx->Color.ColorMask[3]) {
+         masking = GL_FALSE;
+      }
+      else {
+         masking = GL_TRUE;
+      }
+   }
+   else {
+      struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0];
+      const GLuint indexBits = (1 << rb->IndexBits) - 1;
+      if ((ctx->Color.IndexMask & indexBits) == indexBits) {
+         masking = GL_FALSE;
+      }
+      else {
+         masking = GL_TRUE;
+      }
+   }
+
+   for (buf = 0; buf < ctx->DrawBuffer->_NumColorDrawBuffers; buf++) {
+      struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[buf];
+      if (ctx->Visual.rgbMode) {
+         if (masking) {
+            clear_rgba_buffer_with_masking(ctx, rb);
          }
          else {
-            (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_RIGHT);
-            (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, GL_BACK_RIGHT);
+            clear_rgba_buffer(ctx, rb);
          }
-
-         if (colorMask != 0xffffffff) {
-            clear_color_buffer_with_masking(ctx);
+      }
+      else {
+         if (masking) {
+            clear_ci_buffer_with_masking(ctx, rb);
          }
          else {
-            clear_color_buffer(ctx);
+            clear_ci_buffer(ctx, rb);
          }
       }
    }
-
-   /* restore default read/draw buffers */
-   (void) (*ctx->Driver.SetDrawBuffer)( ctx, ctx->Color.DriverDrawBuffer );
-   (void) (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer, ctx->Pixel.DriverReadBuffer );
 }
 
 
-
+/**
+ * Called via the device driver's ctx->Driver.Clear() function if the
+ * device driver can't clear one or more of the buffers itself.
+ * \param buffers  bitfield of BUFFER_BIT_* values indicating which
+ *                 renderbuffers are to be cleared.
+ * \param all  if GL_TRUE, clear whole buffer, else clear specified region.
+ */
 void
-_swrast_Clear( GLcontext *ctx, GLbitfield mask,
-	       GLboolean all,
-	       GLint x, GLint y, GLint width, GLint height )
+_swrast_Clear(GLcontext *ctx, GLbitfield buffers)
 {
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-#ifdef DEBUG
+#ifdef DEBUG_FOO
    {
-      GLbitfield legalBits = DD_FRONT_LEFT_BIT |
-	 DD_FRONT_RIGHT_BIT |
-	 DD_BACK_LEFT_BIT |
-	 DD_BACK_RIGHT_BIT |
-	 DD_DEPTH_BIT |
-	 DD_STENCIL_BIT |
-	 DD_ACCUM_BIT;
-      assert((mask & (~legalBits)) == 0);
+      const GLbitfield legalBits =
+         BUFFER_BIT_FRONT_LEFT |
+	 BUFFER_BIT_FRONT_RIGHT |
+	 BUFFER_BIT_BACK_LEFT |
+	 BUFFER_BIT_BACK_RIGHT |
+	 BUFFER_BIT_DEPTH |
+	 BUFFER_BIT_STENCIL |
+	 BUFFER_BIT_ACCUM |
+         BUFFER_BIT_AUX0 |
+         BUFFER_BIT_AUX1 |
+         BUFFER_BIT_AUX2 |
+         BUFFER_BIT_AUX3;
+      assert((buffers & (~legalBits)) == 0);
    }
 #endif
 
-   RENDER_START(swrast,ctx);
+   swrast_render_start(ctx);
 
    /* do software clearing here */
-   if (mask) {
-      if (mask & ctx->Color.DrawDestMask)   clear_color_buffers(ctx);
-      if (mask & GL_DEPTH_BUFFER_BIT)    _mesa_clear_depth_buffer(ctx);
-      if (mask & GL_ACCUM_BUFFER_BIT)    _mesa_clear_accum_buffer(ctx);
-      if (mask & GL_STENCIL_BUFFER_BIT)  _mesa_clear_stencil_buffer(ctx);
-   }
-
-   /* clear software-based alpha buffer(s) */
-   if ( (mask & GL_COLOR_BUFFER_BIT)
-	&& ctx->DrawBuffer->UseSoftwareAlphaBuffers
-	&& ctx->Color.ColorMask[ACOMP]) {
-      _mesa_clear_alpha_buffers( ctx );
+   if (buffers) {
+      if ((buffers & BUFFER_BITS_COLOR)
+          && (ctx->DrawBuffer->_NumColorDrawBuffers > 0)) {
+         clear_color_buffers(ctx);
+      }
+      if (buffers & BUFFER_BIT_DEPTH) {
+         _swrast_clear_depth_buffer(ctx, ctx->DrawBuffer->_DepthBuffer);
+      }
+      if (buffers & BUFFER_BIT_ACCUM) {
+         _swrast_clear_accum_buffer(ctx,
+                       ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer);
+      }
+      if (buffers & BUFFER_BIT_STENCIL) {
+         _swrast_clear_stencil_buffer(ctx, ctx->DrawBuffer->_StencilBuffer);
+      }
    }
 
-   RENDER_FINISH(swrast,ctx);
-}
-
-
-void
-_swrast_alloc_buffers( GLframebuffer *buffer )
-{
-   /* Reallocate other buffers if needed. */
-   if (buffer->UseSoftwareDepthBuffer) {
-      _mesa_alloc_depth_buffer( buffer );
-   }
-   if (buffer->UseSoftwareStencilBuffer) {
-      _mesa_alloc_stencil_buffer( buffer );
-   }
-   if (buffer->UseSoftwareAccumBuffer) {
-      _mesa_alloc_accum_buffer( buffer );
-   }
-   if (buffer->UseSoftwareAlphaBuffers) {
-      _mesa_alloc_alpha_buffers( buffer );
-   }
+   swrast_render_finish(ctx);
 }