src/mesa/swrast/s_depth.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22  * OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25
  26 #include "main/glheader.h"
  27 #include "main/context.h"
  28 #include "main/formats.h"
  29 #include "main/format_unpack.h"
  30 #include "main/format_pack.h"
  31 #include "main/macros.h"
  32 #include "main/imports.h"
  33
  34 #include "s_context.h"
  35 #include "s_depth.h"
  36 #include "s_span.h"
  37
  38
  39
  40 #define Z_TEST(COMPARE)                      \
  41    do {                                      \
  42       GLuint i;                              \
  43       for (i = 0; i < n; i++) {              \
  44          if (mask[i]) {                      \
  45             if (COMPARE) {                   \
  46                /* pass */                    \
  47                if (write) {                  \
  48                   zbuffer[i] = zfrag[i];     \
  49                }                             \
  50                passed++;                     \
  51             }                                \
  52             else {                           \
  53                /* fail */                    \
  54                mask[i] = 0;                  \
  55             }                                \
  56          }                                   \
  57       }                                      \
  58    } while (0)
  59
  60
  61 /**
  62  * Do depth test for an array of 16-bit Z values.
  63  * @param zbuffer  array of Z buffer values (16-bit)
  64  * @param zfrag  array of fragment Z values (use 16-bit in 32-bit uint)
  65  * @param mask  which fragments are alive, killed afterward
  66  * @return  number of fragments which pass the test.
  67  */
  68 static GLuint
  69 depth_test_span16( struct gl_context *ctx, GLuint n,
  70                    GLushort zbuffer[], const GLuint zfrag[], GLubyte mask[] )
  71 {
  72    const GLboolean write = ctx->Depth.Mask;
  73    GLuint passed = 0;
  74
  75    /* switch cases ordered from most frequent to less frequent */
  76    switch (ctx->Depth.Func) {
  77    case GL_LESS:
  78       Z_TEST(zfrag[i] < zbuffer[i]);
  79       break;
  80    case GL_LEQUAL:
  81       Z_TEST(zfrag[i] <= zbuffer[i]);
  82       break;
  83    case GL_GEQUAL:
  84       Z_TEST(zfrag[i] >= zbuffer[i]);
  85       break;
  86    case GL_GREATER:
  87       Z_TEST(zfrag[i] > zbuffer[i]);
  88       break;
  89    case GL_NOTEQUAL:
  90       Z_TEST(zfrag[i] != zbuffer[i]);
  91       break;
  92    case GL_EQUAL:
  93       Z_TEST(zfrag[i] == zbuffer[i]);
  94       break;
  95    case GL_ALWAYS:
  96       Z_TEST(1);
  97       break;
  98    case GL_NEVER:
  99       memset(mask, 0, n * sizeof(GLubyte));
 100       break;
 101    default:
 102       _mesa_problem(ctx, "Bad depth func in depth_test_span16");
 103    }
 104
 105    return passed;
 106 }
 107
 108
 109 /**
 110  * Do depth test for an array of 32-bit Z values.
 111  * @param zbuffer  array of Z buffer values (32-bit)
 112  * @param zfrag  array of fragment Z values (use 32-bits in 32-bit uint)
 113  * @param mask  which fragments are alive, killed afterward
 114  * @return  number of fragments which pass the test.
 115  */
 116 static GLuint
 117 depth_test_span32( struct gl_context *ctx, GLuint n,
 118                    GLuint zbuffer[], const GLuint zfrag[], GLubyte mask[])
 119 {
 120    const GLboolean write = ctx->Depth.Mask;
 121    GLuint passed = 0;
 122
 123    /* switch cases ordered from most frequent to less frequent */
 124    switch (ctx->Depth.Func) {
 125    case GL_LESS:
 126       Z_TEST(zfrag[i] < zbuffer[i]);
 127       break;
 128    case GL_LEQUAL:
 129       Z_TEST(zfrag[i] <= zbuffer[i]);
 130       break;
 131    case GL_GEQUAL:
 132       Z_TEST(zfrag[i] >= zbuffer[i]);
 133       break;
 134    case GL_GREATER:
 135       Z_TEST(zfrag[i] > zbuffer[i]);
 136       break;
 137    case GL_NOTEQUAL:
 138       Z_TEST(zfrag[i] != zbuffer[i]);
 139       break;
 140    case GL_EQUAL:
 141       Z_TEST(zfrag[i] == zbuffer[i]);
 142       break;
 143    case GL_ALWAYS:
 144       Z_TEST(1);
 145       break;
 146    case GL_NEVER:
 147       memset(mask, 0, n * sizeof(GLubyte));
 148       break;
 149    default:
 150       _mesa_problem(ctx, "Bad depth func in depth_test_span32");
 151    }
 152
 153    return passed;
 154 }
 155
 156
 157 /**
 158  * Clamp fragment Z values to the depth near/far range (glDepthRange()).
 159  * This is used when GL_ARB_depth_clamp/GL_DEPTH_CLAMP is turned on.
 160  * In that case, vertexes are not clipped against the near/far planes
 161  * so rasterization will produce fragment Z values outside the usual
 162  * [0,1] range.
 163  */
 164 void
 165 _swrast_depth_clamp_span( struct gl_context *ctx, SWspan *span )
 166 {
 167    struct gl_framebuffer *fb = ctx->DrawBuffer;
 168    const GLuint count = span->end;
 169    GLint *zValues = (GLint *) span->array->z; /* sign change */
 170    GLint min, max;
 171    GLfloat min_f, max_f;
 172    GLuint i;
 173
 174    if (ctx->ViewportArray[0].Near < ctx->ViewportArray[0].Far) {
 175       min_f = ctx->ViewportArray[0].Near;
 176       max_f = ctx->ViewportArray[0].Far;
 177    } else {
 178       min_f = ctx->ViewportArray[0].Far;
 179       max_f = ctx->ViewportArray[0].Near;
 180    }
 181
 182    /* Convert floating point values in [0,1] to device Z coordinates in
 183     * [0, DepthMax].
 184     * ex: If the Z buffer has 24 bits, DepthMax = 0xffffff.
 185     *
 186     * XXX this all falls apart if we have 31 or more bits of Z because
 187     * the triangle rasterization code produces unsigned Z values.  Negative
 188     * vertex Z values come out as large fragment Z uints.
 189     */
 190    min = (GLint) (min_f * fb->_DepthMaxF);
 191    max = (GLint) (max_f * fb->_DepthMaxF);
 192    if (max < 0)
 193       max = 0x7fffffff; /* catch over flow for 30-bit z */
 194
 195    /* Note that we do the comparisons here using signed integers.
 196     */
 197    for (i = 0; i < count; i++) {
 198       if (zValues[i] < min)
 199          zValues[i] = min;
 200       if (zValues[i] > max)
 201          zValues[i] = max;
 202    }
 203 }
 204
 205
 206 /**
 207  * Get array of 32-bit z values from the depth buffer.  With clipping.
 208  * Note: the returned values are always in the range [0, 2^32-1].
 209  */
 210 static void
 211 get_z32_values(struct gl_context *ctx, struct gl_renderbuffer *rb,
 212                GLuint count, const GLint x[], const GLint y[],
 213                GLuint zbuffer[])
 214 {
 215    struct swrast_renderbuffer *srb = swrast_renderbuffer(rb);
 216    const GLint w = rb->Width, h = rb->Height;
 217    const GLubyte *map = _swrast_pixel_address(rb, 0, 0);
 218    GLuint i;
 219
 220    if (rb->Format == MESA_FORMAT_Z_UNORM32) {
 221       const GLint rowStride = srb->RowStride;
 222       for (i = 0; i < count; i++) {
 223          if (x[i] >= 0 && y[i] >= 0 && x[i] < w && y[i] < h) {
 224             zbuffer[i] = *((GLuint *) (map + y[i] * rowStride + x[i] * 4));
 225          }
 226       }
 227    }
 228    else {
 229       const GLint bpp = _mesa_get_format_bytes(rb->Format);
 230       const GLint rowStride = srb->RowStride;
 231       for (i = 0; i < count; i++) {
 232          if (x[i] >= 0 && y[i] >= 0 && x[i] < w && y[i] < h) {
 233             const GLubyte *src = map + y[i] * rowStride+ x[i] * bpp;
 234             _mesa_unpack_uint_z_row(rb->Format, 1, src, &zbuffer[i]);
 235          }
 236       }
 237    }
 238 }
 239
 240
 241 /**
 242  * Put an array of 32-bit z values into the depth buffer.
 243  * Note: the z values are always in the range [0, 2^32-1].
 244  */
 245 static void
 246 put_z32_values(struct gl_context *ctx, struct gl_renderbuffer *rb,
 247                GLuint count, const GLint x[], const GLint y[],
 248                const GLuint zvalues[], const GLubyte mask[])
 249 {
 250    struct swrast_renderbuffer *srb = swrast_renderbuffer(rb);
 251    const GLint w = rb->Width, h = rb->Height;
 252    GLubyte *map = _swrast_pixel_address(rb, 0, 0);
 253    GLuint i;
 254
 255    if (rb->Format == MESA_FORMAT_Z_UNORM32) {
 256       const GLint rowStride = srb->RowStride;
 257       for (i = 0; i < count; i++) {
 258          if (mask[i] && x[i] >= 0 && y[i] >= 0 && x[i] < w && y[i] < h) {
 259             GLuint *dst = (GLuint *) (map + y[i] * rowStride + x[i] * 4);
 260             *dst = zvalues[i];
 261          }
 262       }
 263    }
 264    else {
 265       gl_pack_uint_z_func packZ = _mesa_get_pack_uint_z_func(rb->Format);
 266       const GLint bpp = _mesa_get_format_bytes(rb->Format);
 267       const GLint rowStride = srb->RowStride;
 268       for (i = 0; i < count; i++) {
 269          if (mask[i] && x[i] >= 0 && y[i] >= 0 && x[i] < w && y[i] < h) {
 270             void *dst = map + y[i] * rowStride + x[i] * bpp;
 271             packZ(zvalues + i, dst);
 272          }
 273       }
 274    }
 275 }
 276
 277
 278 /**
 279  * Apply depth (Z) buffer testing to the span.
 280  * \return approx number of pixels that passed (only zero is reliable)
 281  */
 282 GLuint
 283 _swrast_depth_test_span(struct gl_context *ctx, SWspan *span)
 284 {
 285    struct gl_framebuffer *fb = ctx->DrawBuffer;
 286    struct gl_renderbuffer *rb = fb->Attachment[BUFFER_DEPTH].Renderbuffer;
 287    const GLint bpp = _mesa_get_format_bytes(rb->Format);
 288    void *zStart;
 289    const GLuint count = span->end;
 290    const GLuint *fragZ = span->array->z;
 291    GLubyte *mask = span->array->mask;
 292    void *zBufferVals;
 293    GLuint *zBufferTemp = NULL;
 294    GLuint passed;
 295    GLuint zBits = _mesa_get_format_bits(rb->Format, GL_DEPTH_BITS);
 296    GLboolean ztest16 = GL_FALSE;
 297
 298    if (span->arrayMask & SPAN_XY)
 299       zStart = NULL;
 300    else
 301       zStart = _swrast_pixel_address(rb, span->x, span->y);
 302
 303    if (rb->Format == MESA_FORMAT_Z_UNORM16 && !(span->arrayMask & SPAN_XY)) {
 304       /* directly read/write row of 16-bit Z values */
 305       zBufferVals = zStart;
 306       ztest16 = GL_TRUE;
 307    }
 308    else if (rb->Format == MESA_FORMAT_Z_UNORM32 && !(span->arrayMask & SPAN_XY)) {
 309       /* directly read/write row of 32-bit Z values */
 310       zBufferVals = zStart;
 311    }
 312    else {
 313       if (_mesa_get_format_datatype(rb->Format) != GL_UNSIGNED_NORMALIZED) {
 314          _mesa_problem(ctx, "Incorrectly writing swrast's integer depth "
 315                        "values to %s depth buffer",
 316                        _mesa_get_format_name(rb->Format));
 317       }
 318
 319       /* copy Z buffer values into temp buffer (32-bit Z values) */
 320       zBufferTemp = malloc(count * sizeof(GLuint));
 321       if (!zBufferTemp)
 322          return 0;
 323
 324       if (span->arrayMask & SPAN_XY) {
 325          get_z32_values(ctx, rb, count,
 326                         span->array->x, span->array->y, zBufferTemp);
 327       }
 328       else {
 329          _mesa_unpack_uint_z_row(rb->Format, count, zStart, zBufferTemp);
 330       }
 331
 332       if (zBits == 24) {
 333          GLuint i;
 334          /* Convert depth buffer values from 32 to 24 bits to match the
 335           * fragment Z values generated by rasterization.
 336           */
 337          for (i = 0; i < count; i++) {
 338             zBufferTemp[i] >>= 8;
 339          }
 340       }
 341       else if (zBits == 16) {
 342          GLuint i;
 343          /* Convert depth buffer values from 32 to 16 bits */
 344          for (i = 0; i < count; i++) {
 345             zBufferTemp[i] >>= 16;
 346          }
 347       }
 348       else {
 349          assert(zBits == 32);
 350       }
 351
 352       zBufferVals = zBufferTemp;
 353    }
 354
 355    /* do the depth test either with 16 or 32-bit values */
 356    if (ztest16)
 357       passed = depth_test_span16(ctx, count, zBufferVals, fragZ, mask);
 358    else
 359       passed = depth_test_span32(ctx, count, zBufferVals, fragZ, mask);
 360
 361    if (zBufferTemp) {
 362       /* need to write temp Z values back into the buffer */
 363
 364       /* Convert depth buffer values back to 32-bit values.  The least
 365        * significant bits don't matter since they'll get dropped when
 366        * they're packed back into the depth buffer.
 367        */
 368       if (zBits == 24) {
 369          GLuint i;
 370          for (i = 0; i < count; i++) {
 371             zBufferTemp[i] = (zBufferTemp[i] << 8);
 372          }
 373       }
 374       else if (zBits == 16) {
 375          GLuint i;
 376          for (i = 0; i < count; i++) {
 377             zBufferTemp[i] = zBufferTemp[i] << 16;
 378          }
 379       }
 380
 381       if (span->arrayMask & SPAN_XY) {
 382          /* random locations */
 383          put_z32_values(ctx, rb, count, span->array->x, span->array->y,
 384                         zBufferTemp, mask);
 385       }
 386       else {
 387          /* horizontal row */
 388          gl_pack_uint_z_func packZ = _mesa_get_pack_uint_z_func(rb->Format);
 389          GLubyte *dst = zStart;
 390          GLuint i;
 391          for (i = 0; i < count; i++) {
 392             if (mask[i]) {
 393                packZ(&zBufferTemp[i], dst);
 394             }
 395             dst += bpp;
 396          }
 397       }
 398
 399       free(zBufferTemp);
 400    }
 401
 402    if (passed < count) {
 403       span->writeAll = GL_FALSE;
 404    }
 405    return passed;
 406 }
 407
 408
 409 /**
 410  * GL_EXT_depth_bounds_test extension.
 411  * Discard fragments depending on whether the corresponding Z-buffer
 412  * values are outside the depth bounds test range.
 413  * Note: we test the Z buffer values, not the fragment Z values!
 414  * \return GL_TRUE if any fragments pass, GL_FALSE if no fragments pass
 415  */
 416 GLboolean
 417 _swrast_depth_bounds_test( struct gl_context *ctx, SWspan *span )
 418 {
 419    struct gl_framebuffer *fb = ctx->DrawBuffer;
 420    struct gl_renderbuffer *rb = fb->Attachment[BUFFER_DEPTH].Renderbuffer;
 421    GLubyte *zStart;
 422    GLuint zMin = (GLuint)((double)ctx->Depth.BoundsMin * 0xffffffff);
 423    GLuint zMax = (GLuint)((double)ctx->Depth.BoundsMax * 0xffffffff);
 424    GLubyte *mask = span->array->mask;
 425    const GLuint count = span->end;
 426    GLuint i;
 427    GLboolean anyPass = GL_FALSE;
 428    GLuint *zBufferTemp;
 429    const GLuint *zBufferVals;
 430
 431    zBufferTemp = malloc(count * sizeof(GLuint));
 432    if (!zBufferTemp) {
 433       /* don't generate a stream of OUT_OF_MEMORY errors here */
 434       return GL_FALSE;
 435    }
 436
 437    if (span->arrayMask & SPAN_XY)
 438       zStart = NULL;
 439    else
 440       zStart = _swrast_pixel_address(rb, span->x, span->y);
 441
 442    if (rb->Format == MESA_FORMAT_Z_UNORM32 && !(span->arrayMask & SPAN_XY)) {
 443       /* directly access 32-bit values in the depth buffer */
 444       zBufferVals = (const GLuint *) zStart;
 445    }
 446    else {
 447       /* Round the bounds to the precision of the zbuffer. */
 448       if (rb->Format == MESA_FORMAT_Z_UNORM16) {
 449          zMin = (zMin & 0xffff0000) | (zMin >> 16);
 450          zMax = (zMax & 0xffff0000) | (zMax >> 16);
 451       } else {
 452          /* 24 bits */
 453          zMin = (zMin & 0xffffff00) | (zMin >> 24);
 454          zMax = (zMax & 0xffffff00) | (zMax >> 24);
 455       }
 456
 457       /* unpack Z values into a temporary array */
 458       if (span->arrayMask & SPAN_XY) {
 459          get_z32_values(ctx, rb, count, span->array->x, span->array->y,
 460                         zBufferTemp);
 461       }
 462       else {
 463          _mesa_unpack_uint_z_row(rb->Format, count, zStart, zBufferTemp);
 464       }
 465       zBufferVals = zBufferTemp;
 466    }
 467
 468    /* Now do the tests */
 469    for (i = 0; i < count; i++) {
 470       if (mask[i]) {
 471          if (zBufferVals[i] < zMin || zBufferVals[i] > zMax)
 472             mask[i] = GL_FALSE;
 473          else
 474             anyPass = GL_TRUE;
 475       }
 476    }
 477
 478    free(zBufferTemp);
 479
 480    return anyPass;
 481 }
 482
 483
 484
 485 /**********************************************************************/
 486 /*****                      Read Depth Buffer                     *****/
 487 /**********************************************************************/
 488
 489
 490 /**
 491  * Read a span of depth values from the given depth renderbuffer, returning
 492  * the values as GLfloats.
 493  * This function does clipping to prevent reading outside the depth buffer's
 494  * bounds.
 495  */
 496 void
 497 _swrast_read_depth_span_float(struct gl_context *ctx,
 498                               struct gl_renderbuffer *rb,
 499                               GLint n, GLint x, GLint y, GLfloat depth[])
 500 {
 501    if (!rb) {
 502       /* really only doing this to prevent FP exceptions later */
 503       memset(depth, 0, n * sizeof(GLfloat));
 504       return;
 505    }
 506
 507    if (y < 0 || y >= (GLint) rb->Height ||
 508        x + n <= 0 || x >= (GLint) rb->Width) {
 509       /* span is completely outside framebuffer */
 510       memset(depth, 0, n * sizeof(GLfloat));
 511       return;
 512    }
 513
 514    if (x < 0) {
 515       GLint dx = -x;
 516       GLint i;
 517       for (i = 0; i < dx; i++)
 518          depth[i] = 0.0;
 519       x = 0;
 520       n -= dx;
 521       depth += dx;
 522    }
 523    if (x + n > (GLint) rb->Width) {
 524       GLint dx = x + n - (GLint) rb->Width;
 525       GLint i;
 526       for (i = 0; i < dx; i++)
 527          depth[n - i - 1] = 0.0;
 528       n -= dx;
 529    }
 530    if (n <= 0) {
 531       return;
 532    }
 533
 534    _mesa_unpack_float_z_row(rb->Format, n, _swrast_pixel_address(rb, x, y),
 535                             depth);
 536 }
 537
 538
 539 /**
 540  * Clear the given z/depth renderbuffer.  If the buffer is a combined
 541  * depth+stencil buffer, only the Z bits will be touched.
 542  */
 543 void
 544 _swrast_clear_depth_buffer(struct gl_context *ctx)
 545 {
 546    struct gl_renderbuffer *rb =
 547       ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
 548    GLint x, y, width, height;
 549    GLubyte *map;
 550    GLint rowStride, i, j;
 551    GLbitfield mapMode;
 552
 553    if (!rb || !ctx->Depth.Mask) {
 554       /* no depth buffer, or writing to it is disabled */
 555       return;
 556    }
 557
 558    /* compute region to clear */
 559    x = ctx->DrawBuffer->_Xmin;
 560    y = ctx->DrawBuffer->_Ymin;
 561    width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
 562    height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
 563
 564    mapMode = GL_MAP_WRITE_BIT;
 565    if (rb->Format == MESA_FORMAT_Z24_UNORM_S8_UINT ||
 566        rb->Format == MESA_FORMAT_Z24_UNORM_X8_UINT ||
 567        rb->Format == MESA_FORMAT_S8_UINT_Z24_UNORM ||
 568        rb->Format == MESA_FORMAT_X8_UINT_Z24_UNORM) {
 569       mapMode |= GL_MAP_READ_BIT;
 570    }
 571
 572    ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height,
 573                                mapMode, &map, &rowStride);
 574    if (!map) {
 575       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glClear(depth)");
 576       return;
 577    }
 578
 579    switch (rb->Format) {
 580    case MESA_FORMAT_Z_UNORM16:
 581       {
 582          GLfloat clear = (GLfloat) ctx->Depth.Clear;
 583          GLushort clearVal = 0;
 584          _mesa_pack_float_z_row(rb->Format, 1, &clear, &clearVal);
 585          if (clearVal == 0xffff && width * 2 == rowStride) {
 586             /* common case */
 587             memset(map, 0xff, width * height * 2);
 588          }
 589          else {
 590             for (i = 0; i < height; i++) {
 591                GLushort *row = (GLushort *) map;
 592                for (j = 0; j < width; j++) {
 593                   row[j] = clearVal;
 594                }
 595                map += rowStride;
 596             }
 597          }
 598       }
 599       break;
 600    case MESA_FORMAT_Z_UNORM32:
 601    case MESA_FORMAT_Z_FLOAT32:
 602       {
 603          GLfloat clear = (GLfloat) ctx->Depth.Clear;
 604          GLuint clearVal = 0;
 605          _mesa_pack_float_z_row(rb->Format, 1, &clear, &clearVal);
 606          for (i = 0; i < height; i++) {
 607             GLuint *row = (GLuint *) map;
 608             for (j = 0; j < width; j++) {
 609                row[j] = clearVal;
 610             }
 611             map += rowStride;
 612          }
 613       }
 614       break;
 615    case MESA_FORMAT_Z24_UNORM_S8_UINT:
 616    case MESA_FORMAT_Z24_UNORM_X8_UINT:
 617    case MESA_FORMAT_S8_UINT_Z24_UNORM:
 618    case MESA_FORMAT_X8_UINT_Z24_UNORM:
 619       {
 620          GLfloat clear = (GLfloat) ctx->Depth.Clear;
 621          GLuint clearVal = 0;
 622          GLuint mask;
 623
 624          if (rb->Format == MESA_FORMAT_Z24_UNORM_S8_UINT ||
 625              rb->Format == MESA_FORMAT_Z24_UNORM_X8_UINT)
 626             mask = 0xff000000;
 627          else
 628             mask = 0xff;
 629
 630          _mesa_pack_float_z_row(rb->Format, 1, &clear, &clearVal);
 631          for (i = 0; i < height; i++) {
 632             GLuint *row = (GLuint *) map;
 633             for (j = 0; j < width; j++) {
 634                row[j] = (row[j] & mask) | clearVal;
 635             }
 636             map += rowStride;
 637          }
 638
 639       }
 640       break;
 641    case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
 642       /* XXX untested */
 643       {
 644          GLfloat clearVal = (GLfloat) ctx->Depth.Clear;
 645          for (i = 0; i < height; i++) {
 646             GLfloat *row = (GLfloat *) map;
 647             for (j = 0; j < width; j++) {
 648                row[j * 2] = clearVal;
 649             }
 650             map += rowStride;
 651          }
 652       }
 653       break;
 654    default:
 655       _mesa_problem(ctx, "Unexpected depth buffer format %s"
 656                     " in _swrast_clear_depth_buffer()",
 657                     _mesa_get_format_name(rb->Format));
 658    }
 659
 660    ctx->Driver.UnmapRenderbuffer(ctx, rb);
 661 }
 662
 663
 664
 665
 666 /**
 667  * Clear both depth and stencil values in a combined depth+stencil buffer.
 668  */
 669 void
 670 _swrast_clear_depth_stencil_buffer(struct gl_context *ctx)
 671 {
 672    const GLubyte stencilBits = ctx->DrawBuffer->Visual.stencilBits;
 673    const GLuint writeMask = ctx->Stencil.WriteMask[0];
 674    const GLuint stencilMax = (1 << stencilBits) - 1;
 675    struct gl_renderbuffer *rb =
 676       ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
 677    GLint x, y, width, height;
 678    GLbitfield mapMode;
 679    GLubyte *map;
 680    GLint rowStride, i, j;
 681
 682    /* check that we really have a combined depth+stencil buffer */
 683    assert(rb == ctx->DrawBuffer->Attachment[BUFFER_STENCIL].Renderbuffer);
 684
 685    /* compute region to clear */
 686    x = ctx->DrawBuffer->_Xmin;
 687    y = ctx->DrawBuffer->_Ymin;
 688    width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
 689    height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
 690
 691    mapMode = GL_MAP_WRITE_BIT;
 692    if ((writeMask & stencilMax) != stencilMax) {
 693       /* need to mask stencil values */
 694       mapMode |= GL_MAP_READ_BIT;
 695    }
 696
 697    ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height,
 698                                mapMode, &map, &rowStride);
 699    if (!map) {
 700       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glClear(depth+stencil)");
 701       return;
 702    }
 703
 704    switch (rb->Format) {
 705    case MESA_FORMAT_Z24_UNORM_S8_UINT:
 706    case MESA_FORMAT_S8_UINT_Z24_UNORM:
 707       {
 708          GLfloat zClear = (GLfloat) ctx->Depth.Clear;
 709          GLuint clear = 0, mask;
 710
 711          _mesa_pack_float_z_row(rb->Format, 1, &zClear, &clear);
 712
 713          if (rb->Format == MESA_FORMAT_Z24_UNORM_S8_UINT) {
 714             mask = ((~writeMask) & 0xff) << 24;
 715             clear |= (ctx->Stencil.Clear & writeMask & 0xff) << 24;
 716          }
 717          else {
 718             mask = ((~writeMask) & 0xff);
 719             clear |= (ctx->Stencil.Clear & writeMask & 0xff);
 720          }
 721
 722          for (i = 0; i < height; i++) {
 723             GLuint *row = (GLuint *) map;
 724             if (mask != 0x0) {
 725                for (j = 0; j < width; j++) {
 726                   row[j] = (row[j] & mask) | clear;
 727                }
 728             }
 729             else {
 730                for (j = 0; j < width; j++) {
 731                   row[j] = clear;
 732                }
 733             }
 734             map += rowStride;
 735          }
 736       }
 737       break;
 738    case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
 739       /* XXX untested */
 740       {
 741          const GLfloat zClear = (GLfloat) ctx->Depth.Clear;
 742          const GLuint sClear = ctx->Stencil.Clear & writeMask;
 743          const GLuint sMask = (~writeMask) & 0xff;
 744          for (i = 0; i < height; i++) {
 745             GLfloat *zRow = (GLfloat *) map;
 746             GLuint *sRow = (GLuint *) map;
 747             for (j = 0; j < width; j++) {
 748                zRow[j * 2 + 0] = zClear;
 749             }
 750             if (sMask != 0) {
 751                for (j = 0; j < width; j++) {
 752                   sRow[j * 2 + 1] = (sRow[j * 2 + 1] & sMask) | sClear;
 753                }
 754             }
 755             else {
 756                for (j = 0; j < width; j++) {
 757                   sRow[j * 2 + 1] = sClear;
 758                }
 759             }
 760             map += rowStride;
 761          }
 762       }
 763       break;
 764    default:
 765       _mesa_problem(ctx, "Unexpected depth buffer format %s"
 766                     " in _swrast_clear_depth_buffer()",
 767                     _mesa_get_format_name(rb->Format));
 768    }
 769
 770    ctx->Driver.UnmapRenderbuffer(ctx, rb);
 771
 772 }