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

diff --git a/src/mesa/swrast/s_buffers.c b/src/mesa/swrast/s_buffers.c
index e7889008972..af475ad8cb5 100644
--- a/src/mesa/swrast/s_buffers.c
+++ b/src/mesa/swrast/s_buffers.c
@@ -1,8 +1,8 @@
 /*
  * Mesa 3-D graphics library
- * Version:  6.3
+ * Version:  7.1
  *
- * Copyright (C) 1999-2005  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"),
@@ -22,13 +22,13 @@
  * 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 "colormac.h"
-#include "macros.h"
-#include "imports.h"
-#include "mtypes.h"
-#include "fbobject.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_context.h"
@@ -47,25 +47,58 @@ clear_rgba_buffer_with_masking(GLcontext *ctx, struct gl_renderbuffer *rb)
    const GLint y = ctx->DrawBuffer->_Ymin;
    const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
    const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
-   GLchan clearColor[4];
+   SWspan span;
    GLint i;
 
    ASSERT(ctx->Visual.rgbMode);
    ASSERT(rb->PutRow);
 
-   CLAMPED_FLOAT_TO_CHAN(clearColor[RCOMP], ctx->Color.ClearColor[0]);
-   CLAMPED_FLOAT_TO_CHAN(clearColor[GCOMP], ctx->Color.ClearColor[1]);
-   CLAMPED_FLOAT_TO_CHAN(clearColor[BCOMP], ctx->Color.ClearColor[2]);
-   CLAMPED_FLOAT_TO_CHAN(clearColor[ACOMP], ctx->Color.ClearColor[3]);
+   /* 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 {
+      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++) {
-      GLchan rgba[MAX_WIDTH][4];
-      GLint j;
-      for (j = 0; j < width; j++) {
-         COPY_CHAN4(rgba[j], clearColor);
-      }
-      _swrast_mask_rgba_array( ctx, rb, width, x, y + i, rgba );
-      rb->PutRow(ctx, rb, width, x, y + i, rgba, NULL);
+      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);
    }
 }
 
@@ -80,21 +113,31 @@ clear_ci_buffer_with_masking(GLcontext *ctx, struct gl_renderbuffer *rb)
    const GLint y = ctx->DrawBuffer->_Ymin;
    const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
    const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
-   GLuint span[MAX_WIDTH];
-   GLubyte mask[MAX_WIDTH];
-   GLint i, j;
+   SWspan span;
+   GLint i;
 
    ASSERT(!ctx->Visual.rgbMode);
+   ASSERT(rb->PutRow);
+   ASSERT(rb->DataType == GL_UNSIGNED_INT);
+
+   /* 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;
+   }
 
-   MEMSET( mask, 1, width );
+   /* 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++) {
-      for (j = 0; j < width;j++) {
-         span[j] = ctx->Color.ClearIndex;
-      }
-      _swrast_mask_ci_array(ctx, rb, width, x, y + i, span);
-      ASSERT(rb->PutRow);
-      ASSERT(rb->DataType == GL_UNSIGNED_INT);
-      rb->PutRow(ctx, rb, width, x, y + i, span, mask);
+      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);
    }
 }
 
@@ -125,17 +168,17 @@ clear_rgba_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
 
    switch (rb->DataType) {
       case GL_UNSIGNED_BYTE:
-         clear8[0] = FLOAT_TO_UBYTE(ctx->Color.ClearColor[0]);
-         clear8[1] = FLOAT_TO_UBYTE(ctx->Color.ClearColor[1]);
-         clear8[2] = FLOAT_TO_UBYTE(ctx->Color.ClearColor[2]);
-         clear8[3] = FLOAT_TO_UBYTE(ctx->Color.ClearColor[3]);
+         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:
-         clear16[0] = FLOAT_TO_USHORT(ctx->Color.ClearColor[0]);
-         clear16[1] = FLOAT_TO_USHORT(ctx->Color.ClearColor[1]);
-         clear16[2] = FLOAT_TO_USHORT(ctx->Color.ClearColor[2]);
-         clear16[3] = FLOAT_TO_USHORT(ctx->Color.ClearColor[3]);
+         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:
@@ -170,8 +213,8 @@ clear_ci_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
 
    ASSERT(!ctx->Visual.rgbMode);
 
-   ASSERT((ctx->Color.IndexMask & ((1 << ctx->Visual.indexBits) - 1))
-          == (GLuint) ((1 << ctx->Visual.indexBits) - 1));
+   ASSERT((ctx->Color.IndexMask & ((1 << rb->IndexBits) - 1))
+          == (GLuint) ((1 << rb->IndexBits) - 1));
 
    ASSERT(rb->PutMonoRow);
 
@@ -207,9 +250,8 @@ clear_ci_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
 static void
 clear_color_buffers(GLcontext *ctx)
 {
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
    GLboolean masking;
-   GLuint i;
+   GLuint buf;
 
    if (ctx->Visual.rgbMode) {
       if (ctx->Color.ColorMask[0] && 
@@ -223,7 +265,8 @@ clear_color_buffers(GLcontext *ctx)
       }
    }
    else {
-      const GLuint indexBits = (1 << ctx->Visual.indexBits) - 1;
+      struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0];
+      const GLuint indexBits = (1 << rb->IndexBits) - 1;
       if ((ctx->Color.IndexMask & indexBits) == indexBits) {
          masking = GL_FALSE;
       }
@@ -232,15 +275,8 @@ clear_color_buffers(GLcontext *ctx)
       }
    }
 
-   for (i = 0; i < ctx->DrawBuffer->_NumColorDrawBuffers[0]; i++) {
-      struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0][i];
-#if OLD_RENDERBUFFER || NEW_RENDERBUFFER
-      /* SetBuffer will go away */
-      if (swrast->Driver.SetBuffer)
-         swrast->Driver.SetBuffer(ctx, ctx->DrawBuffer,
-                                  ctx->DrawBuffer->_ColorDrawBit[0][i]);
-#endif
-
+   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);
@@ -258,26 +294,19 @@ clear_color_buffers(GLcontext *ctx)
          }
       }
    }
-
-   /* restore default read/draw buffer */
-   _swrast_use_draw_buffer(ctx);
 }
 
 
 /**
  * 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 mask  bitwise-OR of DD_*_BIT flags.
+ * \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);
-
-   (void) all; (void) x; (void) y; (void) width; (void) height;
-
 #ifdef DEBUG_FOO
    {
       const GLbitfield legalBits =
@@ -292,117 +321,29 @@ _swrast_Clear(GLcontext *ctx, GLbitfield mask,
          BUFFER_BIT_AUX1 |
          BUFFER_BIT_AUX2 |
          BUFFER_BIT_AUX3;
-      assert((mask & (~legalBits)) == 0);
+      assert((buffers & (~legalBits)) == 0);
    }
 #endif
 
-   RENDER_START(swrast,ctx);
+   swrast_render_start(ctx);
 
    /* do software clearing here */
-   if (mask) {
-      if (mask & ctx->DrawBuffer->_ColorDrawBufferMask[0]) {
+   if (buffers) {
+      if ((buffers & BUFFER_BITS_COLOR)
+          && (ctx->DrawBuffer->_NumColorDrawBuffers > 0)) {
          clear_color_buffers(ctx);
       }
-      if (mask & BUFFER_BIT_DEPTH) {
-         struct gl_renderbuffer *rb
-            = ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
-         _swrast_clear_depth_buffer(ctx, rb);
+      if (buffers & BUFFER_BIT_DEPTH) {
+         _swrast_clear_depth_buffer(ctx, ctx->DrawBuffer->_DepthBuffer);
       }
-      if (mask & BUFFER_BIT_ACCUM) {
-         struct gl_renderbuffer *rb
-            = ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer;
-         _swrast_clear_accum_buffer(ctx, rb);
+      if (buffers & BUFFER_BIT_ACCUM) {
+         _swrast_clear_accum_buffer(ctx,
+                       ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer);
       }
-      if (mask & BUFFER_BIT_STENCIL) {
-         struct gl_renderbuffer *rb
-            = ctx->DrawBuffer->Attachment[BUFFER_STENCIL].Renderbuffer;
-         _swrast_clear_stencil_buffer(ctx, rb);
+      if (buffers & BUFFER_BIT_STENCIL) {
+         _swrast_clear_stencil_buffer(ctx, ctx->DrawBuffer->_StencilBuffer);
       }
    }
 
-   RENDER_FINISH(swrast,ctx);
-}
-
-
-/*
- * Fallback for ctx->Driver.DrawBuffer()
- */
-void
-_swrast_DrawBuffer( GLcontext *ctx, GLenum mode )
-{
-   (void) mode;
-   _swrast_use_draw_buffer(ctx);
-}
-
-
-/*
- * Fallback for ctx->Driver.DrawBuffers()
- */
-void
-_swrast_DrawBuffers( GLcontext *ctx, GLsizei n, const GLenum *buffers )
-{
-   _swrast_use_draw_buffer(ctx);
-}
-
-
-/*
- * Setup things so that we read/write spans from the user-designated
- * read buffer (set via glReadPixels).  We usually just have to call
- * this for glReadPixels, glCopyPixels, etc.
- */
-void
-_swrast_use_read_buffer( GLcontext *ctx )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   /* Do this so the software-emulated alpha plane span functions work! */
-   swrast->CurrentBufferBit = ctx->ReadBuffer->_ColorReadBufferMask;
-   /* Tell the device driver where to read/write spans */
-   if (swrast->Driver.SetBuffer)
-      swrast->Driver.SetBuffer(ctx, ctx->ReadBuffer, swrast->CurrentBufferBit);
-}
-
-
-/*
- * Setup things so that we read/write spans from the default draw buffer.
- * This is the usual mode that Mesa's software rasterizer operates in.
- */
-void
-_swrast_use_draw_buffer( GLcontext *ctx )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   /* The user can specify rendering to zero, one, two, or four color
-    * buffers simultaneously with glDrawBuffer()!
-    * We don't expect the span/point/line/triangle functions to deal with
-    * that mess so we'll iterate over the multiple buffers as needed.
-    * But usually we only render to one color buffer at a time.
-    * We set ctx->Color._DriverDrawBuffer to that buffer and tell the
-    * device driver to use that buffer.
-    * Look in s_span.c's multi_write_rgba_span() function to see how
-    * we loop over multiple color buffers when needed.
-    */
-
-   if (ctx->DrawBuffer->_ColorDrawBufferMask[0] & BUFFER_BIT_FRONT_LEFT)
-      swrast->CurrentBufferBit = BUFFER_BIT_FRONT_LEFT;
-   else if (ctx->DrawBuffer->_ColorDrawBufferMask[0] & BUFFER_BIT_BACK_LEFT)
-      swrast->CurrentBufferBit = BUFFER_BIT_BACK_LEFT;
-   else if (ctx->DrawBuffer->_ColorDrawBufferMask[0] & BUFFER_BIT_FRONT_RIGHT)
-      swrast->CurrentBufferBit = BUFFER_BIT_FRONT_RIGHT;
-   else if (ctx->DrawBuffer->_ColorDrawBufferMask[0] & BUFFER_BIT_BACK_RIGHT)
-      swrast->CurrentBufferBit = BUFFER_BIT_BACK_RIGHT;
-   else if (ctx->DrawBuffer->_ColorDrawBufferMask[0] & BUFFER_BIT_AUX0)
-      swrast->CurrentBufferBit = BUFFER_BIT_AUX0;
-   else if (ctx->DrawBuffer->_ColorDrawBufferMask[0] & BUFFER_BIT_AUX1)
-      swrast->CurrentBufferBit = BUFFER_BIT_AUX1;
-   else if (ctx->DrawBuffer->_ColorDrawBufferMask[0] & BUFFER_BIT_AUX2)
-      swrast->CurrentBufferBit = BUFFER_BIT_AUX2;
-   else if (ctx->DrawBuffer->_ColorDrawBufferMask[0] & BUFFER_BIT_AUX3)
-      swrast->CurrentBufferBit = BUFFER_BIT_AUX3;
-   else
-      /* glDrawBuffer(GL_NONE) */
-      swrast->CurrentBufferBit = BUFFER_BIT_FRONT_LEFT; /* we always have this buffer */
-
-   if (swrast->Driver.SetBuffer)
-      swrast->Driver.SetBuffer(ctx, ctx->DrawBuffer, swrast->CurrentBufferBit);
+   swrast_render_finish(ctx);
 }