src/mesa/swrast/s_clear.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.1
   4  *
   5  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #include "main/glheader.h"
  26 #include "main/colormac.h"
  27 #include "main/formats.h"
  28 #include "main/macros.h"
  29 #include "main/imports.h"
  30 #include "main/mtypes.h"
  31
  32 #include "s_accum.h"
  33 #include "s_context.h"
  34 #include "s_depth.h"
  35 #include "s_masking.h"
  36 #include "s_stencil.h"
  37
  38
  39 /**
  40  * Clear the color buffer when glColorMask is in effect.
  41  */
  42 static void
  43 clear_rgba_buffer_with_masking(GLcontext *ctx, struct gl_renderbuffer *rb)
  44 {
  45    const GLint x = ctx->DrawBuffer->_Xmin;
  46    const GLint y = ctx->DrawBuffer->_Ymin;
  47    const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
  48    const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
  49    SWspan span;
  50    GLint i;
  51
  52    ASSERT(ctx->Visual.rgbMode);
  53    ASSERT(rb->PutRow);
  54
  55    /* Initialize color span with clear color */
  56    /* XXX optimize for clearcolor == black/zero (bzero) */
  57    INIT_SPAN(span, GL_BITMAP);
  58    span.end = width;
  59    span.arrayMask = SPAN_RGBA;
  60    span.array->ChanType = rb->DataType;
  61    if (span.array->ChanType == GL_UNSIGNED_BYTE) {
  62       GLubyte clearColor[4];
  63       UNCLAMPED_FLOAT_TO_UBYTE(clearColor[RCOMP], ctx->Color.ClearColor[0]);
  64       UNCLAMPED_FLOAT_TO_UBYTE(clearColor[GCOMP], ctx->Color.ClearColor[1]);
  65       UNCLAMPED_FLOAT_TO_UBYTE(clearColor[BCOMP], ctx->Color.ClearColor[2]);
  66       UNCLAMPED_FLOAT_TO_UBYTE(clearColor[ACOMP], ctx->Color.ClearColor[3]);
  67       for (i = 0; i < width; i++) {
  68          COPY_4UBV(span.array->rgba[i], clearColor);
  69       }
  70    }
  71    else if (span.array->ChanType == GL_UNSIGNED_SHORT) {
  72       GLushort clearColor[4];
  73       UNCLAMPED_FLOAT_TO_USHORT(clearColor[RCOMP], ctx->Color.ClearColor[0]);
  74       UNCLAMPED_FLOAT_TO_USHORT(clearColor[GCOMP], ctx->Color.ClearColor[1]);
  75       UNCLAMPED_FLOAT_TO_USHORT(clearColor[BCOMP], ctx->Color.ClearColor[2]);
  76       UNCLAMPED_FLOAT_TO_USHORT(clearColor[ACOMP], ctx->Color.ClearColor[3]);
  77       for (i = 0; i < width; i++) {
  78          COPY_4V(span.array->rgba[i], clearColor);
  79       }
  80    }
  81    else {
  82       ASSERT(span.array->ChanType == GL_FLOAT);
  83       for (i = 0; i < width; i++) {
  84          CLAMPED_FLOAT_TO_CHAN(span.array->rgba[i][0], ctx->Color.ClearColor[0]);
  85          CLAMPED_FLOAT_TO_CHAN(span.array->rgba[i][1], ctx->Color.ClearColor[1]);
  86          CLAMPED_FLOAT_TO_CHAN(span.array->rgba[i][2], ctx->Color.ClearColor[2]);
  87          CLAMPED_FLOAT_TO_CHAN(span.array->rgba[i][3], ctx->Color.ClearColor[3]);
  88       }
  89    }
  90
  91    /* Note that masking will change the color values, but only the
  92     * channels for which the write mask is GL_FALSE.  The channels
  93     * which which are write-enabled won't get modified.
  94     */
  95    for (i = 0; i < height; i++) {
  96       span.x = x;
  97       span.y = y + i;
  98       _swrast_mask_rgba_span(ctx, rb, &span);
  99       /* write masked row */
 100       rb->PutRow(ctx, rb, width, x, y + i, span.array->rgba, NULL);
 101    }
 102 }
 103
 104
 105 /**
 106  * Clear color index buffer with masking.
 107  */
 108 static void
 109 clear_ci_buffer_with_masking(GLcontext *ctx, struct gl_renderbuffer *rb)
 110 {
 111    const GLint x = ctx->DrawBuffer->_Xmin;
 112    const GLint y = ctx->DrawBuffer->_Ymin;
 113    const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
 114    const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
 115    SWspan span;
 116    GLint i;
 117
 118    ASSERT(!ctx->Visual.rgbMode);
 119    ASSERT(rb->PutRow);
 120    ASSERT(rb->DataType == GL_UNSIGNED_INT);
 121
 122    /* Initialize index span with clear index */
 123    INIT_SPAN(span, GL_BITMAP);
 124    span.end = width;
 125    span.arrayMask = SPAN_INDEX;
 126    for (i = 0; i < width;i++) {
 127       span.array->index[i] = ctx->Color.ClearIndex;
 128    }
 129
 130    /* Note that masking will change the color indexes, but only the
 131     * bits for which the write mask is GL_FALSE.  The bits
 132     * which are write-enabled won't get modified.
 133     */
 134    for (i = 0; i < height;i++) {
 135       span.x = x;
 136       span.y = y + i;
 137       _swrast_mask_ci_span(ctx, rb, &span);
 138       /* write masked row */
 139       rb->PutRow(ctx, rb, width, x, y + i, span.array->index, NULL);
 140    }
 141 }
 142
 143
 144 /**
 145  * Clear an rgba color buffer without channel masking.
 146  */
 147 static void
 148 clear_rgba_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
 149 {
 150    const GLint x = ctx->DrawBuffer->_Xmin;
 151    const GLint y = ctx->DrawBuffer->_Ymin;
 152    const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
 153    const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
 154    GLubyte clear8[4];
 155    GLushort clear16[4];
 156    GLvoid *clearVal;
 157    GLint i;
 158
 159    ASSERT(ctx->Visual.rgbMode);
 160
 161    ASSERT(ctx->Color.ColorMask[0] &&
 162           ctx->Color.ColorMask[1] &&
 163           ctx->Color.ColorMask[2] &&
 164           ctx->Color.ColorMask[3]);
 165
 166    ASSERT(rb->PutMonoRow);
 167
 168    switch (rb->DataType) {
 169       case GL_UNSIGNED_BYTE:
 170          UNCLAMPED_FLOAT_TO_UBYTE(clear8[0], ctx->Color.ClearColor[0]);
 171          UNCLAMPED_FLOAT_TO_UBYTE(clear8[1], ctx->Color.ClearColor[1]);
 172          UNCLAMPED_FLOAT_TO_UBYTE(clear8[2], ctx->Color.ClearColor[2]);
 173          UNCLAMPED_FLOAT_TO_UBYTE(clear8[3], ctx->Color.ClearColor[3]);
 174          clearVal = clear8;
 175          break;
 176       case GL_UNSIGNED_SHORT:
 177          UNCLAMPED_FLOAT_TO_USHORT(clear16[0], ctx->Color.ClearColor[0]);
 178          UNCLAMPED_FLOAT_TO_USHORT(clear16[1], ctx->Color.ClearColor[1]);
 179          UNCLAMPED_FLOAT_TO_USHORT(clear16[2], ctx->Color.ClearColor[2]);
 180          UNCLAMPED_FLOAT_TO_USHORT(clear16[3], ctx->Color.ClearColor[3]);
 181          clearVal = clear16;
 182          break;
 183       case GL_FLOAT:
 184          clearVal = ctx->Color.ClearColor;
 185          break;
 186       default:
 187          _mesa_problem(ctx, "Bad rb DataType in clear_color_buffer");
 188          return;
 189    }
 190
 191    for (i = 0; i < height; i++) {
 192       rb->PutMonoRow(ctx, rb, width, x, y + i, clearVal, NULL);
 193    }
 194 }
 195
 196
 197 /**
 198  * Clear color index buffer without masking.
 199  */
 200 static void
 201 clear_ci_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
 202 {
 203    const GLint x = ctx->DrawBuffer->_Xmin;
 204    const GLint y = ctx->DrawBuffer->_Ymin;
 205    const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
 206    const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
 207    GLubyte clear8;
 208    GLushort clear16;
 209    GLuint clear32;
 210    GLvoid *clearVal;
 211    GLint i;
 212
 213    ASSERT(!ctx->Visual.rgbMode);
 214
 215    ASSERT(rb->PutMonoRow);
 216
 217    /* setup clear value */
 218    switch (rb->DataType) {
 219       case GL_UNSIGNED_BYTE:
 220          clear8 = (GLubyte) ctx->Color.ClearIndex;
 221          clearVal = &clear8;
 222          break;
 223       case GL_UNSIGNED_SHORT:
 224          clear16 = (GLushort) ctx->Color.ClearIndex;
 225          clearVal = &clear16;
 226          break;
 227       case GL_UNSIGNED_INT:
 228          clear32 = ctx->Color.ClearIndex;
 229          clearVal = &clear32;
 230          break;
 231       default:
 232          _mesa_problem(ctx, "Bad rb DataType in clear_color_buffer");
 233          return;
 234    }
 235
 236    for (i = 0; i < height; i++)
 237       rb->PutMonoRow(ctx, rb, width, x, y + i, clearVal, NULL);
 238 }
 239
 240
 241 /**
 242  * Clear the front/back/left/right/aux color buffers.
 243  * This function is usually only called if the device driver can't
 244  * clear its own color buffers for some reason (such as with masking).
 245  */
 246 static void
 247 clear_color_buffers(GLcontext *ctx)
 248 {
 249    GLboolean masking;
 250    GLuint buf;
 251
 252    if (ctx->Visual.rgbMode) {
 253       if (ctx->Color.ColorMask[0] &&
 254           ctx->Color.ColorMask[1] &&
 255           ctx->Color.ColorMask[2] &&
 256           ctx->Color.ColorMask[3]) {
 257          masking = GL_FALSE;
 258       }
 259       else {
 260          masking = GL_TRUE;
 261       }
 262    }
 263    else {
 264       struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0];
 265       const GLuint indexMask = (1 << _mesa_get_format_bits(rb->Format, GL_INDEX_BITS)) - 1;
 266       if ((ctx->Color.IndexMask & indexMask) == indexMask) {
 267          masking = GL_FALSE;
 268       }
 269       else {
 270          masking = GL_TRUE;
 271       }
 272    }
 273
 274    for (buf = 0; buf < ctx->DrawBuffer->_NumColorDrawBuffers; buf++) {
 275       struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[buf];
 276       if (ctx->Visual.rgbMode) {
 277          if (masking) {
 278             clear_rgba_buffer_with_masking(ctx, rb);
 279          }
 280          else {
 281             clear_rgba_buffer(ctx, rb);
 282          }
 283       }
 284       else {
 285          if (masking) {
 286             clear_ci_buffer_with_masking(ctx, rb);
 287          }
 288          else {
 289             clear_ci_buffer(ctx, rb);
 290          }
 291       }
 292    }
 293 }
 294
 295
 296 /**
 297  * Called via the device driver's ctx->Driver.Clear() function if the
 298  * device driver can't clear one or more of the buffers itself.
 299  * \param buffers  bitfield of BUFFER_BIT_* values indicating which
 300  *                 renderbuffers are to be cleared.
 301  * \param all  if GL_TRUE, clear whole buffer, else clear specified region.
 302  */
 303 void
 304 _swrast_Clear(GLcontext *ctx, GLbitfield buffers)
 305 {
 306 #ifdef DEBUG_FOO
 307    {
 308       const GLbitfield legalBits =
 309          BUFFER_BIT_FRONT_LEFT |
 310          BUFFER_BIT_FRONT_RIGHT |
 311          BUFFER_BIT_BACK_LEFT |
 312          BUFFER_BIT_BACK_RIGHT |
 313          BUFFER_BIT_DEPTH |
 314          BUFFER_BIT_STENCIL |
 315          BUFFER_BIT_ACCUM |
 316          BUFFER_BIT_AUX0;
 317       assert((buffers & (~legalBits)) == 0);
 318    }
 319 #endif
 320
 321    swrast_render_start(ctx);
 322
 323    /* do software clearing here */
 324    if (buffers) {
 325       if ((buffers & BUFFER_BITS_COLOR)
 326           && (ctx->DrawBuffer->_NumColorDrawBuffers > 0)) {
 327          clear_color_buffers(ctx);
 328       }
 329       if (buffers & BUFFER_BIT_DEPTH) {
 330          _swrast_clear_depth_buffer(ctx, ctx->DrawBuffer->_DepthBuffer);
 331       }
 332       if (buffers & BUFFER_BIT_ACCUM) {
 333          _swrast_clear_accum_buffer(ctx,
 334                        ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer);
 335       }
 336       if (buffers & BUFFER_BIT_STENCIL) {
 337          _swrast_clear_stencil_buffer(ctx, ctx->DrawBuffer->_StencilBuffer);
 338       }
 339    }
 340
 341    swrast_render_finish(ctx);
 342 }